Programmation Arduino – Les bases

Arduino, Domotique, RobotiquePas de commentaire

Vous êtes ici :, Domotique, RobotiqueProgrammation Arduino – Les bases

Dans cet article nous allons nous pencher sur les bases de la programmation Arduino. Une fois cet article assimilé, vous aurez non seulement la capacité de suivre correctement le reste des articles/tutoriels de ce site, mais aussi des aptitudes en algorithmique et une aisance à apprendre d’autres langages de programmation.

Si vous n’avez pas les idées claires sur l’Arduino, je vous suggère fortement de jeter un oeil à L’essentiel de L’Arduino.

Questions d’introduction

  • Qu’est ce qu’un langage de programmation ?

Comme le Français, l’Anglais ou l’Espagnol, un langage de programmation n’est ni plus ni moins un moyen de communiquer avec… un ordinateur. Comme tout autre langage, le langage de programmation a ses règles de syntaxe. L’inconvénient c’est que, contrairement à un étranger qui va essayer de vous comprendre, en programmation si vous ne respectez pas scrupuleusement les règles de syntaxes, le programme ne se lance pas. Il y a quand même un avantage majeur : tous les langages de programmations se ressemblent. Par exemple, si vous pouvez programmer en Arduino, vous programmerez en PHP sans problèmes.

  • Comment fonctionne un programme ?

Un programme (ou code) se lit de haut en bas. Il est constitué de séries d’instructions et de conditions qui rendent le programme dynamique. Lorsque nous exécutons le programme, on dit qu’il est compilé (c’est-à-dire traduit en langage binaire) pour l’ordinateur et à ce moment là, le programme fonctionne.

  • Faut-il être fort en mathématiques pour programmer ?

Absolument pas. Si vous savez en quoi consiste l’addition, la soustraction, la division et la multiplication alors le monde de la programmation vous appartient.

  • Mais alors, où est la difficulté ?

La difficulté réside dans le fait d’imaginer comment automatiser une tâche et penser comme une machine. Convertir une activité humaine en une série d’instructions. Exemple : un humain peut très bien, à l’aide de ses yeux, détecter un mouvement en face de lui. Comment donner cette capacité à un ordinateur ? Comment traduire ceci en langage de programmation ? Ce sont le genre de questions auxquelles sont confrontés les programmeurs.

 

I. Variables, Constantes et Types

Admettons que votre but est de mettre en place un programme qui sonde la température d’une pièce. Où va t-il la stocker ? C’est le rôle des variables et des constantes de stocker l’information.

Admettons que la température de la pièce soit de 27°. En langage Arduino on écrirait ainsi :

int temperature = 27;

Ici, int signifie Integer en anglais qui veut dire entier en Français. On indique alors à l’Arduino que le type de donnée que nous allons stocker est un entier (27).

temperature c’est le nom de la variable que je viens de créer, j’aurai très bien pu l’appeller autrement; il faut simplement retenir que le nom d’une variable ne doit pas contenir d’espace ou de caractères spéciaux comme des « é » ou encore des « à ».
= 27 attribue le nombre 27 à la variable temperature, c’est à dire que si l’on sollicite la variable temperature, l’Arduino va nous indiquer 27.

Vous avez sans doute remarqué la présence d’un point virgule à la fin de la déclaration de la variable. Sachez qu’il faut mettre un point virgule à chaque expression que vous écrirez en langage Arduino. C’est d’ailleurs la raison pour laquelle vous allez faire des erreurs au début et c’est tout à fait normal, c’est une habitude à prendre.

Nous avons parlé de variables et de constantes, ici temperature est une variable. C’est à dire que l’on peut la modifier à tout moment dans le programme. Pour ce faire, rien de plus simple, admettons que la température soit maintenant de 31° on écrirait ainsi :

temperature = 31;

La variable temperature est alors égale à 31.

Mais si nous avions déclaré temperature en tant que constante et non variable, nous n’aurions pas la possibilité de la modifier. Pour déclarer une constante, il suffit de rajouter const avant le type de données.

const int temperature = 31;

Pourquoi déclarer des constantes alors que je pourrais déclarer des variables et juste ne pas les modifier dans mon programme ?

Vous pouvez. Seulement, il s’agit d’une question de sécurité et d’optimisation. Pour faire simple, lorsque vous indiquez à l’Arduino ou un ordinateur en général que vous utilisez une constante, c’est-à-dire que votre donnée ne va pas subir de modification au cours du programme, alors, le compilateur peut optimiser votre code et le rendre plus performant, plus rapide. Il est évident que pour les petits programmes que nous faisons, nous n’allons guère ressentir la différence, mais à grande échelle cela devient crucial.

Prenez l’habitude, en programmation, d’être précis dans tout ce que vous écrivez, cela vous permettra d’écrire un code sans ambiguïté et plus performant.

En parlant de précision, vous avez  remarqué que nous avons aussi indiqué pour notre variable qu’il s’agissait d’un entier. Il existe, comme vous pouvez vous en douter plusieurs types de données en langage Arduino :

 

  • Entier

Tout simplement un chiffre ou un nombre, on le déclare avec int

int monChiffre = 556;

 

  • Chiffre à virgule

Il s’agit d’un décimal, on le déclare avec float

float monDecimal = 47,5678;

 

  • Chaîne de caractère

C’est un peu plus spécial cette fois ci, on la déclare avec String. Prenons un exemple :

String maChaine = "Bonjour";

Une chaîne de caractère doit obligatoirement être mise entre des guillemets comme ci-dessus. Si je n’avais pas mis les guillemets «  » à ma chaîne « Bonjour », mon programme aurait pu comprendre que je faisais une référence à une variable se nommant Bonjour.

 

  • Booléen

Le type booléen est un type spécial, il peut prendre deux valeurs : true ou false, littéralement vrai ou faux :

boolean monBooleen = true;
boolean monAutreBooleen = false;

L’intérêt ? Il va nous être très utile dans les tests et conditions, vous comprendrez plus tard. Considérez seulement que vrai et faux correspondent au binaire de l’ordinateur 1 et 0. Ils sont donc très importants.

 

 

II. Maths, Print et Concaténation

Dans cette partie nous allons voir trois éléments importants qui vont vous servir quand vous allez écrire votre code.

  • Maths

Rassurez vous, nous n’allons pas faire de calculs poussés, je vais simplement vous montrer les opérations de bases :D.

Admettons que vous possédez la température de trois pièces de votre maison et que vous voulez avoir la température moyenne dans la maison. Commençons par déclarer les variables :

int tempChambre = 27;

int tempCuisine = 25;

int tempSalon = 30;

 

Calculons la moyenne des températures :

int sommeDesTemp = tempChambre + tempCuisine + tempSalon;

On peut en effet créer une variable et lui attribuer la valeur d’une autre variable ou alors comme ici : la somme de plusieurs variables. Pour l’addition on utilise le signe « + », la soustraction « -« , la multiplication « * » et la division « / ».

Donc la moyenne serait :

int tempMoyenne = sommeDesTemp / 3;

En version améliorée, le code serait :

int tempChambre = 27;

int tempCuisine = 25;

int tempSalon = 30;


int nombreDePieces = 3; //On met une variable qui contient le nombre de pièces.


int tempMoyenne = (tempChambre+tempCuisine+tempSalon) / nombreDePieces;

(Ce qui suit les « // » s’appelle un commentaire, très utile si vous oubliez l’utilité d’une instruction où que vous partagez votre programme avec un groupe de personne. Les commentaires sont ignorés à l’exécution du code.)

Donc si on rentre le calcul dans la calculatrice, on a : 27,33333333333…

Seulement, tempMoyenne vaudra uniquement 27. Pourquoi ? Si vous avez remarqué, nous avons déclaré nos variables en tant qu’entiers (int). Et donc une division d’entiers donnent forcément… un entier. Pour avoir un résultat à virgule, il faudrait alors déclarer toutes nos variables en un autre type vu auparavant : le float.

On écrira ainsi :

float tempChambre = 27.0;

float tempCuisine = 25.0;

float tempSalon = 30.0;


int nombreDePieces = 3; 


float tempMoyenne = (tempChambre+tempCuisine+tempSalon) / nombreDePieces;

 

Maintenant que nous avons notre température moyenne, il serait bon de l’afficher quelque part.

 

  • Print

Il existe de nombreuses possibilités pour afficher ou transmettre l’information quelque part. Vous pouvez l’afficher sur un panneau LCD ou tout simplement à l’écran ou l’envoyer sur un serveur.

En anglais Print veut dire Imprimer et c’est ce que nous allons faire : imprimer sur notre écran nos données.

Quand on travail avec Arduino et Print, on affiche les données dans ce qu’on appelle:  un moniteur de série.

Le moniteur de série permet de communiquer en direct avec l’Arduino. Il se présente sous la forme d’une boite de dialogue avec une entrée et une sortie. Pour ouvrir le moniteur de série, ouvrez l’IDE Arduino, connectez votre carte, assurez vous qu’elle soit bien détectée par le logiciel et cliquez sur l’icône « loupe » en haut à droite.

Essayons :

Ouvrez un nouveau fichier dans l’IDE et écrivez ceci :

float tempChambre = 27.0;

float tempCuisine = 25.0;

float tempSalon = 30.0;


int nombreDePieces = 3; 

float tempMoyenne = (tempChambre+tempCuisine+tempSalon) / nombreDePieces;

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

void loop() {
  
  // put your main code here, to run repeatedly:

}

Il s’agit du code que nous avons écrit plus haut.

Vous pouvez voir dans la fonction setup() deux nouveaux éléments.

le Serial.print() est tout simplement le fameux print. Entre les parenthèses nous avons mis tempMoyenne qui est une variable que l’on veut afficher. On peut mettre entre ces parenthèse vraiment n’importe quoi, très utile pour faire des tests.

le Serial.begin() est obligatoire et indique à l’Arduino que nous allons utiliser son service moniteur de série (serial veut dire série). Nous avons mis 9600 à l’intérieur. C’est en fait le débit à laquelle l’information va passer : ici 9600 bytes par seconde.

Téléversez ce code vers l’Arduino et ouvrez le moniteur de série. Lorsque le téléversement est terminé vous devez voir apparaître la température moyenne dans le moniteur.

Comme dit un peu plus haut, le print est un outil très puissant pour tester et débuguer votre programme. Vous pouvez en mettre partout et donc vérifier que vos variables ont bien la valeur que vous souhaitez.

 

  • Concaténation

Rien de bien méchant non plus, ce terme pompeux désigne simplement la fusion de deux ou plusieurs chaînes de caractères.

Exemple :

String maChaine1 = "Bonjour ";
String maChaine2 = "tout le monde !";

String chaineConcat = maChaine1 + maChaine2;

Essayez de faire par vous même un petit programme qui affiche dans le serial la variable chaineConcat. Si vous n’y arrivez vraiment pas la solution est juste ici :

String maChaine1 = "Bonjour ";
String maChaine2 = "tout le monde !";

String chaineConcat = maChaine1 + maChaine2;
void setup() {
  // put your setup code here, to run once:
 
  
  Serial.begin(9600);
  Serial.print(chaineConcat); //Affiche "Bonjour tout le monde !"
}

void loop() {
  
  // put your main code here, to run repeatedly:

}

 

III. Structures de contrôle

Que serait un bon programme sans les structures de contrôle ? Ce serait un programme non dynamique.

Les petits programmes que nous avons établis jusqu’à présent sont parfaits pour vous apprendre à programmer mais sont quelques peu ennuyeux. Le but de la programmation est d’arriver à construire un programme autonome prenant des décisions en fonction des éléments qu’on lui fournit. Dans cette partie, nous allons voir les 4 structures de contrôle les plus importantes.

  • If… else

S’il pleut je sors avec mon parapluie, sinon je sors sans parapluie.

La structure If…else correspond tout simplement à une condition : en anglais if…else veut dire si…sinon en français.

Vous devez apprendre par cœur un petit tableau d’opérateurs de comparaison :

tableau-operateurs

Ce tableau sera valable pour toutes les structures de contrôle.

Notez que lorsque l’on teste l’égalité on utilise un double égal au lieu d’un simple égal, tout simplement car le signe égal est déjà utilisé lorsque l’on déclare une variable.

Voici comment ça marche :

if-explain

Dans cet exemple, on test si 10 est supérieur à 5 ou pas. Si c’est vrai, on exécute ce qu’on écrit entre les accolades entourées de vert. Si c’est faux on exécute ce qu’on écrit entre les accolades entourées de jaune. On test si ce qu’il y a entre les parenthèses est vrai ou faux, vous vous souvenez des types Booléens qui prennent soit la valeur vrai ou faux ? Vous commencez donc à comprendre l’utilité de ce type.

Donc vu que 10 est supérieur à 5, la condition est vraie et on exécute ce qu’il y a dans les accolades entourées de vert. Ce qu’il y a après (dans les accolades du else) est ignoré.

Bien entendu, tester si 10 est supérieur à 5 n’a pas grand intérêt, voici un exemple très concret de ce que l’on pourrait faire avec un if…else en domotique :

int tempSalon = 0; //On initialise la variable à 0 parce qu'au début on a aucune donnée.


void setup() {
  
  Serial.begin(9600); //On ouvre le serial

}

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 


}

}

Dans cette exemple, on récupère la température et on l’analyse : si la température est inférieure à 20 alors on exécute ce qu’il y a dans les { } sinon on exécute ce qu’il y a dans les {} du else . Et grâce à la boucle loop, l’Arduino va checker la température constamment.

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.


}

Le else…if rajoute donc autant de possibilités que vous voulez, étant donné que vous pouvez le dupliquer selon vos désirs.

Par contre, si vous avez besoin de beaucoup de else if, il va falloir songer à utiliser une autre structure de contrôle baptisée le switch.

  • Switch

Le switch est un if…else optimisé permettant d’avoir beaucoup plus de possibilités rapidement :

switch (votreVariable) {   //On test une variable,chaine ou nombre (comme un if...else).
    
   case 1:
      Serial.print("votreVariable vaut 1");
      break;

    case 2:
      Serial.print("votreVariable vaut 2");
      break; 

    case "Bonjour": 
      Serial.print("votreVariable vaut "Bonjour"");
      break; 

    default: 
      Serial.print("votreVariable ne vaut aucun des choix proposés ci-dessus");
      break; 
}

Donc, entre les parenthèses du switch on entre la variable/chaine/nombre à tester puis, on énumère des cas (case en anglais). Et juste après case on écrit ce que vaudrait la variable à tester.

Vous avez sans doute remarqué un cas default dans notre switch. C’est en fait l’équivalent du else dans la structure if…else. C’est à dire que si aucun cas n’est vérifié, alors ce qui se trouve dans default sera exécuté.

NB : default est totalement facultatif, vous n’êtes pas obligé d’en mettre un dans un switch.

On note aussi l’apparition d’une instruction nommée break. En anglais break veut dire casser en français. On « casse » le switch. Cette instruction est très utile car elle permet d’indiquer au programme que l’on veut sortir du switch. Il faut savoir que le switch va tester chacun des cas, même si un cas à déjà été vérifié auparavant. Un potentiel gain de temps et d’efficacité.

  • While

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-explain

Comme avec le if…else, nous indiquons l’expression à tester entre les parenthèses.

Avant de rentrer dans le while nous avons indiqué a l’Arduino que maVariable valait 0. Dans le while on vérifie : est ce que maVariable, autrement dit 0 est inférieure ou égale à 10 ? Oui, l’expression est donc vraie, donc on exécute ce qu’il y a entre les accolades du while tant que c’est vrai.

Et pour cause, ce que j’ai écris dans le while va nous permettre de sortir de cette boucle.

On a : maVariable = maVariable + 1;

On attribue à maVariable sa propre valeur plus le chiffre 1. 0+1 étant égal à 1, maVariable vaudra alors 1.

Le while étant une boucle va alors recommencer à vérifier si maVariable est inférieur ou égale à 10, et va recommencer les étapes énoncées ci-dessus.

Au bout d’un moment, à force de passer dans la boucle et donc d’incrémenter (ajouter 1), maVariable vaudra 11 et sera supérieure à 10, elle invalidera donc l’expression (qui devient fausse) pour sortir du while.

NB : Si maVariable valait un chiffre supérieur ou égal à 11 en début de programme, le contenu du while ne se serait pas exécuté vu que 11 est supérieur à 10. On ne rentre que si l’expression est vraie.

Vous l’aurez compris, while est tout simplement une boucle avec des réglages que vous définissez. C’est un outil puissant et parfois dangereux. En effet, si je n’avais pas incrémenté maVariable, nous n’aurions pas eu de chance de sortir de cette boucle; c’est ce que l’on appelle une boucle infinie et c’est à éviter dans tous vos programmes car elle se répète jusqu’à faire crasher votre programme, ou pire, votre ordinateur.

Lorsque j’ai commencé la programmation, je trouvais la boucle while très simple à utiliser mais il m’arrivait de faire planter mon programme. Il existe une autre boucle qui ressemble à un while , mais en moins risqué. C’est notre dernière structure de contrôle, il s’agit du for.

  • For

Avant de voir comment utiliser cette boucle, revenons sur ce phénomène d’incrémentation.

L’incrémentation comme indiqué plus haut est l’action d’ajouter un nombre à une variable. Le phénomène inverse s’appelle la décrémentation et c’est l’action de soustraire un nombre à une variable. L’incrémentation et la décrémentation se font très souvent avec le chiffre 1. On a vu que l’on pouvait incrémenter de cette manière :

maVariable = maVariable + 1;

Mais les programmeurs étant en général des « fainéants » (tout comme moi :D) on peut réduire cette expression à ceci :

maVariable++;

Et si l’on veut faire l’effet inverse (décrémenter de 1) on écrit comme ceci :

maVariable--;

Maintenant que vous savez tout ce qu’il faut savoir sur l’incrémentation passons à la boucle for :

Avec le while, nous avons :

  1. Déclaré notre variable.
  2. Placé la condition entre les parenthèses du while.
  3. Incrémenté notre variable de manière à sortir de la boucle selon nos souhaits.

Ces trois étapes étaient séparées. Avec for tout est sur la même ligne !

for-explain

Dans le carré jaune on déclare notre variable, dans le carré vert on indique la condition (comme dans le if…else et même while), puis dans le carré bleu on indique l’incrémentation/décrémentation. Vous vous en doutez surement mais l’incrémentation va s’appliquer à chaque fois que la boucle fait un tour.

A l’intérieur de la boucle for, les instructions à exécuter.

Mais alors, pourquoi utiliser la boucle while au lieu de for vu que ça représente une sécurité accrue et un gain de temps lors de l’écriture du programme ?

 

Justement, avec la boucle while tout est fait manuellement, ainsi on a + de marge de manœuvre quand on code quelque chose de précis.

 

Maintenant que vous avez fait connaissance avec ces 4 structures, je vous recommande fortement de les toutes les essayer jusqu’à ce que vous compreniez leurs fonctionnement. Vous avez tous les outils fondamentaux (la concaténation, print…) pour tester ces structures de contrôle.

Il est très probable que vous ne saisissiez pas complètement l’intérêt de tout ceci et c’est parfaitement normal. Tout ceci n’est pas à apprendre par cœur, tout ce retient en pratiquant. Lorsque vous serez face à certaines problématiques solvables par le code, ces structures de contrôle vont vous venir à l’esprit et cet article vous permettra de comprendre comment elles fonctionnent précisément.

 

IV. Fonctions

Les programmeurs sont « fainéants », c’est connu. Pour cela on a inventé le copié/collé, mais mieux que ça, on a inventé les fonctions.

Sans le savoir, jusqu’à maintenant, certaines instructions que nous avons utilisé sont des fonctions, j’utilisais alors le mot « instruction » pour ne pas vous perdre.

Par exemple, Serial.print(), Serial.begin() sont des fonctions. Setup() et loop() sont aussi des fonctions, ce sont les fonctions fondamentales.

Mais au final, à quoi ça sert une fonction ?

Prenons un exemple, admettons que vous ayez à écrire 10 fois les mêmes 300 instructions. 10 x 300 : 3000 lignes de code. C’est beaucoup trop et c’est illisible. Ce que l’on  va faire c’est créer une fonction où l’on rentre ces 300 instructions, et dans notre programme on appelle cette même fonction 10 fois.

Vous l’aurez compris, le principe d’une fonction c’est de ne pas écrire un nombre incalculable de lignes de code et de rendre votre programme plus agréable à lire. Vous imaginez si nous avions eu besoin de réécrire toutes les lignes de code de la fonction Serial.print() à chaque fois que nous voulions l’utiliser ?

Les fonctions sont un peu comme des « sous programmes » auxquels vous faites appel dans votre programme principal.

Pour simplifier, on dira qu’il y a deux types de fonctions, les fonctions silencieuses et les fonctions bruyantes.

  • Fonctions silencieuses

Les fonctions silencieuses sont celles qui, quand on les appelles, exécutent le code qu’elles contiennent sans afficher quoi que ce soit, on dit alors qu’elles ne renvoient rien.

Exemple de fonction silencieuse :

checktemp

On utilise void pour déclarer une fonction qui ne renvoi rien (d’où le nom « fonctions silencieuses »), void en anglais veut dire « vide » en français.

On nomme la fonction, ici checkTemperature.

On met deux parenthèses, vous verrez leurs utilité un peu plus tard.

On ouvre les accolades dans lesquelles on ajoute les instructions qui composent la fonction.

Du fait, lorsque l’on veut appeler notre fonction dans notre programme, on écrit : checkTemperature(); et les instructions qui se trouvent dans la fonction vont s’exécuter. Pratique non ?

On peut même créer des fonctions silencieuses plus complexes :

chauffageoupas

Le contenu d’une fonction peut vraiment être ce que vous désirez.

 

  • Fonctions bruyantes

Les fonctions bruyantes, à contrario de celles vues jusqu’à présent renvoient une donnée.

Nous voulons créer une fonction qui permettrait d’additionner deux chiffres. On écrit :

addition

Regardez bien, nous avons remplacé void par un type de donnée que la fonction va renvoyer. Nous avons mis int car la donnée que renvoie notre addition est un entier.

Ensuite on nomme la fonction (ici, addition).

Vous vous souvenez des parenthèses vides avec les exemples plus haut ?

Entre les parenthèses on place ce que l’on appelle des arguments et cela rend l’utilité de la fonction bien plus intéressante. En effet, grâce aux arguments, notre fonction va pouvoir travailler en fonction des variables données par l’utilisateur. On peut mettre autant d’arguments que l’on veut et de n’importe quel type.

Ici, nous avons déclarés deux arguments. L’entier chiffre1 et l’entier chiffre2 (veillez à bien séparer les arguments par des points-virgules/virgules). chiffre1 et chiffre2 sont les chiffres que la fonction va additionner.

A l’intérieur de la fonction on déclare un entier, qui s’appelle resultat, qui va contenir justement le resultat de l’addition. On ajoute donc chiffre1 et chiffre2 qui, je le rappelle, auront pour valeurs celles données lors de l’appel de la fonction. Le comportement de la fonction va varier par rapport aux valeurs définies par l’utilisateur.

Ensuite nous avons le return. Return est la valeur que va retourner la fonction. Mais qu’est ce que cela veut bien dire ?

Tout simplement, la fonction va avoir pour valeur ce qu’elle retourne. Si l’entier resultat vaut 4, alors la fonction addition vaut 4. D’où la spécification du type de fonction.

On attribue souvent une fonction bruyante à une variable, par exemple :

int monNombre = addition(2, 3);

monNombre sera alors égal à 5. Notez que l’on peut aussi donner des variables en arguments, du moment qu’elles sont du même type que les arguments attendus.

Pour finir, il est important de mentionner qu’un programme se lisant de haut en bas, les fonctions doivent être déclarées avant leurs utilisations.

Exemple de code utilisant une fonction :

int chiffre1 = 10;
int chriffre2 = 12;

int addition(int premierChiffre; int deuxiemeChiffre){
    
    int resultat = premierChiffre + deuxiemeChiffre;

    return resultat;

}
void setup() {

  Serial.begin(9600);
  int monCalcul = addition(chiffre1, chiffre2);
  Serial.print(monCalcul);
   
}

void loop() {
  
  // put your main code here, to run repeatedly:

}

 

Je vous suggère fortement de tester par vous même les fonctions avec l’Arduino pour pouvoir véritablement comprendre comment elles fonctionnent. Même si vous ne comprenez pas bien l’intérêt d’avoir des fonctions dans notre programme il est important pour la suite de savoir comment les manipuler. Aussi, n’hésitez pas à lire et relire cet article, si ça ne suffit toujours pas, je vous invite à mettre un commentaire en exposant clairement votre problème :-).

 

 

 

À propos de l'auteur

Laisser un commentaire

Haut