[ Arduino 106] Le langage Arduino (2/2)

J’ai une question. Si je veux faire que le code que j’ai écrit se répète, je suis obligé de le recopier autant de fois que je veux ? Ou bien il existe une solution ? o_O

Voilà une excellente question qui introduit le chapitre que vous allez commencer à lire car c’est justement l’objet de ce chapitre. Nous allons voir comment faire pour qu’un bout de code se répète. Puis nous verrons, ensuite, comment organiser notre code pour que celui-ci devienne plus lisible et facile à débugger. Enfin, nous apprendrons à utiliser les tableaux qui nous seront très utiles. Voilà le programme qui vous attend ! 😉

Les boucles

Qu’est-ce qu’une boucle ?

En programmation, une boucle est une instruction qui permet de répéter un bout de code. Cela va nous permettre de faire se répéter un bout de programme ou un programme entier. Il existe deux types principaux de boucles :

  • La boucle conditionnelle, qui teste une condition et qui exécute les instructions qu’elle contient tant que la condition testée est vraie.
  • La boucle de répétition, qui exécute les instructions qu’elle contient, un nombre de fois prédéterminé.

La boucle while

Problème : Je veux que le volet électrique de ma fenêtre se ferme automatiquement quand la nuit tombe. Nous ne nous occuperons pas de faire le système qui ferme le volet à l’arrivée de la nuit. La carte Arduino dispose d’un capteur qui indique la position du volet (ouvert ou fermé). Ce que nous cherchons à faire : c’est créer un bout de code qui fait descendre le volet tant qu’il n’est pas fermé. Pour résoudre le problème posé, il va falloir que l’on utilise une boucle.

Comment lire ce code ?

En anglais, le mot while signifie « tant que ». Donc si on lit la ligne :

Il faut la lire : « TANT QUE la position du volet est ouvert« , on boucle/répète les instructions de la boucle (entre les accolades).

Construction d’une boucle while

Voilà donc la syntaxe de cette boucle qu’il faut retenir :

Un exemple

Prenons un exemple simple, réalisons un compteur !

Si on teste ce code (dans la réalité rien ne s’affiche, c’est juste un exemple pour vous montrer), cela donne :

Donc au départ, la variable compteur vaut 0, on exécute la boucle et on incrémente compteur. Mais compteur ne vaut pour l’instant que 1, donc on ré-exécute la boucle. Maintenant compteur vaut 2. On répète la boucle, … jusqu’à 5. Si compteur vaut 5, la boucle n’est pas ré-exécutée et on continu le programme. Dans notre cas, le programme se termine.

La boucle do…while

Cette boucle est similaire à la précédente. Mais 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 :

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 ».

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. Reprenons notre compteur :

Dans ce code, on définit dès le départ la valeur de compteur à 5. Or, le programme va rentrer dans la boucle alors que la condition est fausse. Donc la boucle est au moins exécutée une fois ! Et ce quelle que soit la véracité de la condition. En test cela donne :

Concaténation

Une boucle est une instruction qui a été répartie sur plusieurs lignes. Mais on peut l’écrire sur une seule ligne :

C’est pourquoi il ne faut pas oublier le point virgule à la fin (après le while). Alors que dans une simple boucle while le point virgule ne doit pas être mis !

La boucle for

Voilà une boucle bien particulière. Ce qu’elle va nous permettre de faire est assez simple. Cette boucle est exécutée X fois. Contrairement aux deux boucles précédentes, on doit lui donner trois paramètres.

Fonctionnement

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

Donc, si on li cette ligne : « POUR compteur = 0 et compteur inférieur à 5, on incrémente compteur ». De façon plus concise, la boucle est exécutée autant de fois qu’il sera nécessaire à compteur pour arriver à 5. Donc ici, le code qui se trouve à l’intérieur de la boucle sera exécuté 5 fois.

A retenir

La structure de la boucle :

La boucle infinie

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.

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 » :

Cela ne fonctionnera pas avec la valeur 0. En effet, 0 signifie « condition fausse » donc la boucle s’arrêtera aussitôt…

La fonction loop() se comporte comme une boucle infinie, puisqu’elle se répète après avoir fini d’exécuter ses tâches.

Les fonctions

Dans un programme, les lignes sont souvent très nombreuses. Il devient alors impératif de séparer le programme en petits bouts afin d’améliorer la lisibilité de celui-ci, en plus d’améliorer le fonctionnement et de faciliter le débogage. Nous allons voir ensemble ce qu’est une fonction, puis nous apprendrons à les créer et les appeler.

Qu’est-ce qu’une fonction ?

Une fonction est un « conteneur » mais différent des variables. En effet, une variable ne peut contenir qu’un nombre, tandis qu’une fonction peut contenir un programme entier ! Par exemple ce code est une fonction :

En fait, lorsque l’on va programmer notre carte Arduino, on va écrire notre programme dans des fonctions. Pour l’instant nous n’en connaissons que 2 : setup() et loop(). Dans l’exemple précédent, à la place du commentaire, on peut mettre des instructions (conditions, boucles, variables, …). C’est ces instructions qui vont constituer le programme en lui même. Pour être plus concret, une fonction est un bout de programme qui permet de réaliser une tâche bien précise. Par exemple, pour mettre en forme un texte, on peut colorier un mot en bleu, mettre le mot en gras ou encore grossir ce mot. A chaque fois, on a utilisé une fonction :

  • gras, pour mettre le mot en gras
  • colorier, pour mettre le mot en bleu
  • grossir, pour augmenter la taille du mot

En programmation, on va utiliser des fonctions. Alors ces fonctions sont « réparties dans deux grandes familles ». Ce que j’entends par là, c’est qu’il existe des fonctions toutes prêtes dans le langage Arduino et d’autres que l’on va devoir créer nous même. C’est ce dernier point qui va nous intéresser.

On ne peut pas écrire un programme sans mettre de fonctions à l’intérieur ! On est obligé d’utiliser la fonction setup() et loop() (même si on ne met rien dedans). Si vous écrivez des instructions en dehors d’une fonction, le logiciel Arduino refusera systématiquement de compiler votre programme. Il n’y a que les variables globales que vous pourrez déclarer en dehors des fonctions.

J’ai pas trop compris à quoi ça sert ? o_O

L’utilité d’une fonction réside dans sa capacité à simplifier le code et à le séparer en « petits bouts » que l’on assemblera ensemble pour créer le programme final. Si vous voulez, c’est un peu comme les jeux de construction en plastique : chaque pièce à son propre mécanisme et réalise une fonction. Par exemple une roue permet de rouler ; un bloc permet de réunir plusieurs autres blocs entre eux ; un moteur va faire avancer l’objet créé… Et bien tous ces éléments seront assemblés entre eux pour former un objet (voiture, maison, …). Tout comme, les fonctions seront assemblées entre elles pour former un programme. On aura par exemple la fonction : « mettre au carré un nombre » ; la fonction : « additionner a + b » ; etc. Qui au final donnera le résultat souhaité.

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. Bon, des noms on peut lui en donner plein, mais soyez logique quant au choix de ce dernier. Ce sera plus facile pour comprendre le code que si vous l’appelez tmp (pour température 😉 ).

Un nom de fonction explicite garantit une lecture rapide et une compréhension aisée du code. Un lecteur doit savoir ce que fait la fonction juste grâce à son nom, sans lire le contenu !

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.

Notez qu’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). Ainsi, la référence nous explique que la fonction a les caractéristiques suivantes:

  • – 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

Comme vous pouvez le constater, l’exemple est explicite sans lire le code de la fonction. Son nom, digitalWrite (« écriture digitale » pour les anglophobes), signifie qu’on va changer l’état d’une broche numérique (donc pas analogique). Ses paramètres ont eux aussi des noms explicites, pin pour la broche à changer et value pour l’état à lui donner. Lorsque vous aller créer des fonctions, c’est à vous de voir si elles ont besoin de paramètres ou non. 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.

Mais c’est quoi ça « void » ?

J’y arrive ! Souvenez vous, un peu plus haut je vous expliquais qu’une fonction pouvait retourner une valeur, la fameuse valeur de sortie, je vais maintenant vous expliquer son fonctionnement.

Le type void

On vient de voir qu’une fonction pouvait accepter des paramètres et éventuellement renvoyer quelque chose. Mais ce n’est pas obligatoire. En effet, si l’on reprend notre fonction « Pause », elle ne renvoie rien car ce n’est pas nécessaire de signaler quoi que ce soit. Dans ce cas, on préfixera le nom de notre fontion avec le mot-clé « void ». La syntaxe utilisée est la suivante :

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 :

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é. Vous connaissez d’ailleurs déjà au moins deux fonctions qui n’ont pas de retour… Et oui, la fonction « setup » et la fonction « loop » 😉 . Il n’y en a pas plus à savoir. 😉

Les fonctions « typées »

Là, cela devient légèrement plus intéressant. En effet, 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, …)

Comment créer une fonction typée ?

En soit, cela n’a rien de compliqué, il faut simplement remplacer long, …) Voilà un exemple :

Notez que je n’ai pas mis les deux fonctions principales, à savoir loop(), mais elles sont obligatoires ! Lorsqu’elle sera appelée, la fonction resultat. Voyez cet exemple :

Dans la fonction calcul = 10 * 44; Ce qui nous donne : calcul = 440. Bon ce n’est qu’un exemple très simple pour vous montrer un peu comment cela fonctionne. Plus tard, lorsque vous serez au point, vous utiliserez certainement cette combinaison de façon plus complexe. 😉

Comme cet exemple est très simple, je n’ai pas inscrit la valeur retournée par la fonction maFonction() dans une variable, mais il est préférable de le faire. Du moins, lorsque c’est utile, ce qui n’est pas le cas ici.

Les fonctions avec paramètres

C’est bien gentil tout ça, mais maintenant vous allez voir quelque chose de bien plus intéressant. Voilà un code, nous verrons ce qu’il fait après :

Que se passe-t-il ?

J’ai défini trois variables : maFonction() est « typée » et accepte des paramètres. Lisons le code du début :

  • On déclare nos variables
  • La fonction maFonction() que l’on a créée

C’est sur ce dernier point que l’on va se pencher. En effet, on a donné à la fonction des paramètres. Ces paramètres servent à « nourrir » la fonction. Pour faire simple, on dit à la fonction : « Voilà deux paramètres, je veux que tu t’en serves pour faire le calcul que je veux » Ensuite arrive la signature de la fonction.

La signature… de quoi tu parles ?

La signature c’est le « titre complet » de la fonction. Grâce à elle on connait le nom de la fonction, le type de la valeur retourné, et le type des différents paramètres.

La fonction récupère dans des variables les paramètres que l’on lui a envoyés. Autrement dit, dans la variable y. Soit : param2 = y = 192. Pour finir, on utilise ces deux variables créées « à la volée » dans la signature de la fonction pour réaliser le calcul souhaité (une somme dans notre cas).

A quoi ça sert de faire tout ça ? Pourquoi on utilise pas simplement les variables x et y dans la fonction ?

Cela va nous servir à simplifier notre code. Mais pas seulement ! Par exemple, 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« . Ce que cela donnerait :

Plus clair qu’un enchaînement de « if », n’est-ce pas ? 😉

Les tableaux

Comme son nom l’indique, cette partie va parler des tableaux.

Quel est l’intérêt de parler de cette surface ennuyeuse qu’utilisent nos chers enseignants ?

Eh bien détrompez-vous, en informatique un tableau ça n’a rien à voir ! Si on devait (beaucoup) résumer, un tableau est une grosse variable. Son but est de stocker des éléments de mêmes types en les mettant dans des cases. Par exemple, un prof qui stocke les notes de ses élèves. Il utilisera un tableau de float (nombre à virgule), avec une case par élèves. Nous allons utiliser cet exemple tout au long de cette partie. Voici quelques précisions pour bien tout comprendre :

  • chaque élève sera identifié par un numéro allant de 0 (le premier élève) à 19 (le vingtième élève de la classe)
  • on part de 0 car en informatique la première valeur dans un tableau est 0 !

Un tableau en programmation

Un tableau, tout comme sous Excel, c’est un ensemble constitué de cases, lesquels vont contenir des informations. En programmation, ces informations seront des nombres. Chaque case d’un tableau contiendra une valeur. En reprenant l’exemple des notes des élèves, le tableau répertoriant les notes de chaque élève ressemblerait à ceci :

élève 0 élève 1 élève 2 […] élève n-1 élève n
10 15,5 8 […] 18 7

A quoi ça sert ?

On va principalement utiliser des tableaux lorsque l’on aura besoin de stocker des informations sans pour autant créer une variable pour chaque information. Toujours avec le même exemple, au lieu de créer une variable eleve2 et ainsi de suite pour chaque élève, on inscrit les notes des élèves dans un tableau.

Mais, concretement c’est quoi un tableau : une variable ? une fonction ?

Ni l’un, ni l’autre. En fait, on pourrait comparer cela avec un index qui pointe vers les valeurs de variables qui sont contenus dans chaque case du tableau. Un petit schéma pour simplifier :

élève 0 élève 1
variable dont on ne connaît pas le nom mais qui stocke une valeur idem, mais variable différente de la case précédente

Par exemple, cela donnerait :

élève 0 élève 1
variable note_eleve0 variable note_eleve1

Avec notre exemple :

élève 0 élève 1
10 15,5

Soit, lorsque l’on demandera la valeur de la case 1 (correspondant à la note de l’élève 1), le tableau nous renverra le nombre : 15,5. Alors, dans un premier temps, on va voir comment déclarer un tableau et l’initialiser. Vous verrez qu’il y a différentes manières de procéder. Après, on finira par apprendre comment utiliser un tableau et aller chercher des valeurs dans celui-ci. Et pour finir, on terminera ce chapitre par un exemple. Y’a encore du boulot ! 😉

Déclarer un tableau

Comme expliqué plus tôt, un tableau contient des éléments de même type. On le déclare donc avec un type semblable, et une taille représentant le nombre d’éléments qu’il contiendra. Par exemple, pour notre classe de 20 étudiants :

On peut également créer un tableau vide, la syntaxe est légèrement différente :

On veut stocker des notes, donc des valeurs décimales entre 0 et 20. On va donc créer un tableau de float (car c’est le type de variable qui accepte les nombres à virgule, souvenez-vous ! 😉 ). Dans cette classe, il y a 20 élèves (de 0 à 19) donc le tableau contiendra 20 éléments. Si on voulait faire un tableau de 100 étudiants dans lesquels on recense leurs nombres d’absence, on ferait le tableau suivant:

Accéder et modifier une case du tableau

Pour accéder à une case d’un tableau, il suffit de connaître l’indice de la case à laquelle on veut accéder. L’indice c’est le numéro de la case qu’on veut lire/écrire. Par exemple, pour lire la valeur de la case 10 (donc indice 9 car on commence à 0):

Ce code se traduit par l’enregistrement de la valeur contenue dans la dixième case du tableau, dans une variable nommée valeur. A présent, si on veut aller modifier cette même valeur, on fait comme avec une variable normale, il suffit d’utiliser l’opérateur ‘ = ‘ :

En fait, on procède de la même manière que pour changer la valeur d’une variable, car, je vous l’ai dit, chaque case d’un tableau est une variable qui contient une valeur ou non.

Faites attention aux indices utilisés. Si vous essayez de lire/écrire dans une case de tableau trop loin (indice trop grand, par exemple 987362598412 😛 ), le comportement pourrait devenir imprévisible. Car en pratique vous modifierez des valeurs qui seront peut-être utilisées par le système pour autre chose. Ce qui pourrait avoir de graves conséquences !

Vous avez sûrement rencontré des crashs de programme sur votre ordinateur, ils sont souvent dû à la modification de variable qui n’appartiennent pas au programme, donc l’OS « tue » ce programme qui essai de manipuler des trucs qui ne lui appartiennent pas.

Initialiser un tableau

Au départ, notre tableau était vide :

Ce que l’on va faire, c’est initialiser notre tableau. On a la possibilité de remplir chaque case une par une ou bien utiliser une boucle qui remplira le tableau à notre place. Dans le premier cas, on peut mettre la valeur que l’on veut dans chaque case du tableau, tandis qu’avec la deuxième solution, on remplira les cases du tableau avec la même valeur, bien que l’on puisse le remplir avec des valeur différentes mais c’est un peu plus compliqué. Dans notre exemple des notes, on part du principe que l’examen n’est pas passé, donc tout le monde à 0. 😛 Pour cela, on parcourt toutes les cases en leur mettant la valeur 0 :

L’initialisation d’un tableau peut se faire directement lors de sa création, comme ceci :

Ou bien même, comme cela :

Exemple de traitement

Bon c’est bien beau tout ça, on a des notes coincées dans un tableau, on en fait quoi ? 🙄

Excellente question, et ça dépendra de l’usage que vous en aurez 🙂 ! Voyons des cas d’utilisations pour notre tableau de notes (en utilisant des fonctions 😉 ).

La note maximale

Comme le titre l’indique, on va rechercher la note maximale (le meilleur élève de la classe). La fonction recevra en paramètre le tableau de float, le nombre d’éléments dans ce tableau et renverra la meilleure note.

Ce que l’on fait, pour lire un tableau, est exactement la même chose que lorsqu’on l’initialise avec une boucle for.

Il est tout à fait possible de mettre la valeur de la case recherché dans une variable :

Voila, ce n’était pas si dur, vous pouvez faire pareil pour chercher la valeur minimale afin vous entrainer !

Calcul de moyenne

Ici, on va chercher la moyenne des notes. La signature de la fonction sera exactement la même que celle de la fonction précédente, à la différence du nom ! Je vous laisse réfléchir, voici la signature de la fonction, le code est plus bas mais essayez de le trouver vous-même avant :

Une solution :

Secret: Réponse SelectionnerAfficher
On en termine avec les tableaux, on verra peut être plus de choses en pratique. 🙂

Maintenant vous pouvez pleurer, de joie bien sûr, car vous venez de terminer la première partie ! A présent, faisons place à la pratique…

86 commentaires

    • Nop… Par contre tu peux faire avec des defines et ensuite les utiliser dans ton tableau :

  1. Bonjour,
    N’y aurait-il pas un problème de texte dans l’article, en particulier sur l’explication des fonctions ?
    Débutant en C j’ai pas très bien compris les explications. Qui par ailleurs sont très claires et bien tournées.
    Merci pour le boulot en passant. Très agréable à lire….

      • Je pense qu’il parle de la page 73 « Ce code ne fonctionnera pas, parce que la fonction int. »
        Ou de la page 76 « Donc si la variable x. Simple à comprendre, n’est ce pas ?  »
        Bon c’est les pages du PDF mais il y a les même erreurs sur le site.

        Si j’ai pu aider, c’était un plaisir 🙂

        En tout cas très bon boulot ,très intéressant.

          • Salut, je commence ton tutoriel, apparemment tu n’as toujours pas corrigé ? ^^ Bon ça reste compréhensible 😉
            Bravo pour ton tutoriel, et merci 🙂

          • Voila j’ai fait des corrections pour la partie en ligne mais je ne me rappelle plus du tout ce que je voulais écrire par endroit XD J’ai du faire une fausse manipulation a un moment !

          • Je cite « Lorsqu’elle sera appelée, la fonction [encadréetencouleur]resultat[/encadréetencouleur]. Voyez cet exemple : »
            Je pense que la mise en forme utilisée pour donner un effet « code » au nom de la fonction supprime certains mots à la suite.
            Tu peux vérifier stp ?

    • Non, pas de tuto en particulier sur break. Cependant normalement l’utilisation est assez directe : « S’il y a un break alors on sort de la boucle courante ». Il resterait juste a trouver la bonne condition pour sortir de la boucle.

  2. Bonjour,

    Il y a un problème, dans cette phrase :
    « Et bien, dans une while, si la condition est vraie dès le départ, on entrera jamais dans cette boucle. »

    Si la condition est vrai, je pense que l’on doit entrer dans la boucle (enfin, je crois…)

    Sinon, excellent tuto

  3. Bonjour,

    Juste un petit message pour signaler quelques petits problèmes de texte dans la partie Fonctions typées, notamment « En soit, cela n’a rien de compliqué, il faut simplement remplacer long, …) », ou encore « Lorsqu’elle sera appelée, la fonction resultat. Voyez cet exemple ». Ce ne sont que des fautes mineures mais si je peux aider, pourquoi pas 🙂
    En tout cas, excellent tuto, hâte de le lire en entier !

  4. Bonjour,
    Nous sommes deux élèves de première SSI et nous devons nous intéresser à la programmation Arduino pour nos TPE, qui consistent à créer un compteur d’électricité qui affiche en euros. Nous avons terminé l’acquisition de la tension analogique (d’ailleurs merci pour ça :)) et nous devons maintenant acquérir heure par heure une valeur pour obtenir des valeurs par heure donc, mais aussi par jour et par mois. Nous avons donc commencé à passer un bon moment à copier coller un bout de programme (donc 24 par jour) et nous aimerions savoir si tu as une solution plus pratique et rapide.désolé si c’est un peu confus et merci pour les bases 🙂

    • Salut !

      Pour l’assistance « projet » je te/vous conseille de venir ouvrir un sujet sur le forum de Zeste de Savoir rubrique « Systèmes et Matériel » de préférence. J’y passe souvent et sera ravi de venir vous y aider pour ce projet qui semble très intéressant.

      La zone de commentaire ici servira plus aux remarques/questions sur le tuto.

  5. Bonjour

    Au départ assez effrayé par le retour à la programmation ( mes derniers programmes datent du Basic sur Commodore64 ;-), je dois dire qu’en parcourant ces deux tutos j’ai moins d’appréhension et que je vais approfondir !

    Explications claires, précises, exemples bien choisis.(Sauf pour le choix GPS ou voiture grise) ou il doit y avoir un méli mélo !! Ou alors j’ai raté un truc…

    Bref, merci d’avoir pris le temps d’écrire ces tutos pour nous en faire profiter, gratuitement en plus, dans l’esprit Arduino en somme !!

    Bon boulot, je me mets à la suite

    PS : une chose..est-ce que les valeurs dans les tableaux doivent obligatoirement être des chiffres ou bien peut on créer et retrouver des valeurs autres ? ..texte par exemple

    Merci encore pour ce travail monumental !

    • PS : une chose..est-ce que les valeurs dans les tableaux doivent obligatoirement être des chiffres ou bien peut on créer et retrouver des valeurs autres ? ..texte par exemple

      Oui dans d’autres langages plus haut niveau (python par exemple), non pour Arduino. Un tableau contient un seul type de données par tableau et s’y tient. Les textes (ou « chaines de caractères ») sont des cas particuliers puisque ce sont « un tableau de char ». Pour faire un tableau de chaîne de caractère, il faudrait donc faire…un tableau de tableau ! (mais nous reparlerons plus tard des chaines de caractères plus tard dans le tutoriel)

    • Bien sur ! En utilisant un || pour le OU ou && pour le ET. Par exemple « tant que la broche 2 OU la broche 3 est a l’état haut :

  6. Salut
    j’ai un projet fin d’etude et je dois programmer un arduino et un servomoteur et une camera de surveillance , je dois faire la programmation de telle façon que le PC doit afficher ce que le camera de surveillance capte.SVP si quelqu’un peut m’aider et merci

    • Si tu espères placer l’Arduino pour faire un relais de transmission alors oubli, l’Arduino n’est pas du tout assez puissante pour traiter de l’image. Le mieux qu’elle pourra faire c’est activer ou non l’alimentation de la camera.

    • Dans ce cas je te conseille de relire le morceau ou de lire en parallèle un autre tuto (qui utilise Arduino ou le langage C, c’est pareil pour les tableaux) car je ne vois pas trop comment je pourrais reformuler une partie entière.

  7. Bonjour Eskimon !
    Je dois programmer un capteur de débit d’eau de manière a faire la moyenne de la consommation d’eau dans un temps donné ( ici, 30s par cycles ).
    Pour ça, je vais calculer le débit en fonction de la fréquence que m’enverra le capteur, et la consommation d’eau en fonction du débit.
    Je souhaite ensuite faire une moyenne sur 10 minutes ( donc 20 fois 30 secondes ), hors, je n’ai pas très bien compris comment insérer mes résultats obtenus dans un tableau
    Pourrait-m’expliquer ? ^^

  8. Salut Eskimon,
    Dans le cadre d’un projet au lycée, je dois programmer Arduino pour alimenter des pompes. La commande est envoyée à Arduino par Bluetooth sous forme de tableau, mais comment je fais pour le lire ? De même, je dois envoyer des informations par Bluetooth et changer des valeurs du tableau, comment je fais ?

  9. Bonjour Eskimon,
    Je tiens à dire que je suis beaucoup tous tes tuto et qu’ils sont vraiment bien réaliser.
    Ma question est la suivante:
    Mon travail consiste à enregistrer des scores de tir à l’arc sur carte SD
    grâce à l’intermédiaire de l’Ethernet shield.
    Je souhaite enregistrer ces scores dans un tableau en 3 dimension….
    1er paramètre= identifiant, le second=numéro de la volée et mon troisième= scores de chaque flèches
    tableau[1,1,1]=10 identifiant numéro 1 dans la case volée numéro 1/flèche numéro 1=10
    Je ne sais pas très bien utiliser les tableaux… si tu pourrait me donner deux trois conseil.
    Merci d’avance! 🙂

      • D’accord je vais leurs poser la question et expliquer plus précisément en quoi consiste mon travail.
        Heureusement que je n’est pas parler d’écran lcd, d’xbee pro, de badge rfid, d’arduino mega, de clavier que je doit utiliser et j’en passe ^^
        Bonne journée à toi 😉

  10. Bonjour,
    Est il possible d’égaliser 2 tableaux comme on égalise 2 variables ?
    Du genre, Tableau1 est déclaré et initialisé. Puis faire Tableau2=Tableau1. J’ai l’impression que non pour avoir essayé mais j’espère encore qu’il existe une possibilité.
    Merci par avance.

  11. Pingback: 03 – Le langage Arduino | BlogOtchi

  12. Tout d’abord mille merci à toi Eskimon pour ce chef-d’oeuvre de vulgarisation,
    Même moi ,j’ai presque tout compris( c est vrai aussi que j en suis qu au deuxième chapitre 😉
    J’ ai quand même une question concernant les type de variable, qui me turlupine a la lecture de la solution du problème concernant la moyenne de note, si j ai bien compris les variables « moyenneNote » et « moyenne » sont de type -flouât, mais pourquoi avoir choisi le type -double pour la variable « totale » ,? Et qu’es qui différencie ces deux type ?

    • C’est plus ou moins une typo ici car dans les faits float et double sont la même chose sur Arduino. en revanche, sur un ordinateur classique le double est en général « plus gros » que le float et peut alors contenir des valeurs plus grandes.

  13. bonjour, je suis tombé sur ton site parce que je chercher comment faire pour remplir un tableau sur arduino avec les valeurs d’un capteur.

    j’ai finalement réussit a faire ça, j’aimerai savoir ce que tu en pense stp 🙂

    • A quoi sert ton tableau ? Car la de ce que je comprend tu met la valeur mesuree dedans, puis fais la moyenne des valeurs. Sauf que tu as juste la valeur de la boucle, a chaque fois ton tableau est detruit/recree. Il faudrait le faire en dehors de la boucle et faire tourner les valeurs dedans.

      • ah d’accord ! ^^ merci. enfaite je dois aquérir 10 valeurs du capteur et faire la moyenne j’ai besoin du tableau pour stocker ces valeurs. je dois faire une moyenne parceque les valeurs en sorti du capteur varie trop. je dois donc faire un deux boucle la premier pour remplir le tableau et la second qui contiendra donc la premier boucle pour refaire le tableau et afficher de nouveau une moyenne avec 10 valeurs différentes.
        j’ai modifier le programme mais je n’arrive pas a compiler …

        #define SOUND_SENSOR A0

        const int analogInPin = A0; //mettre le capteur sur A0

        int sensorValue = 0;
        int db ;

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

        while (TRUE) { //boucle qui se répète à l’infinie

        void loop() {
        sensorValue = analogRead(analogInPin);

        Serial.print(« sensor =  » );
        Serial.println(sensorValue);

        double db = 0.1279*sensorValue ; //formule découlant de la caractéristique du capteur sonore
        }

        float tab[11] = {db}; //remplir tableau avec 10 valeurs du capteur qui se suive

        int somme = 0 ;

        for (int i = 0 ; i < 11 ; i++)
        {
        somme += tab[11] ; //somme des valeurs (db) du tableau
        }

        float dbm = somme / 10.0 ; //valeur moyenne

        Serial.print("db = "); //affichage dbm
        Serial.println(dbm);

        delay(1000);
        }

  14. Pingback: Arduino | Pearltrees

  15. Pingback: Arduino | Pearltrees

  16. Bonjour, ce site est une vraie mine d’informations, et en plus en bon français ! Merci vraiment, j’y puise beaucoup d’infos pour débuter avec un arduino.

    Maintenant du concret : peut-on faire une fonction qui revoie un tableau ?

    je m’explique : pour organiser ma programmation, j’ai une fonction qui acquiert les données et qui les renvoie vers loop() puis ces données sont affichées avec une autre fonction dédiée. Mais comme j’ai plusieurs données, j’aurais voulu que ma fonction qui fait l’acquisition me renvoie un tableau, mais je ne sais pas comment déclarer la fonction. Apparemment ceci ne compile pas : « toot many arguments to function ‘int donnees()’

    int donnees[3]() {
    int temperature = 25;
    int humidite = 63;
    int luminosite = 99;

    donnees = {temperature, humidite, luminosite};

    return donnees;
    }

    une idée ? Merci !

  17. Bonjour Eskimon, dans le cadre d’un projet pour mon BTS, je dois programmer un Arduino.
    Je dois prendre la dernière lettre de la trame qu’y sera envoyer par un programme, et allumé une LED si celle-ci est un C et en allumé une autre si celle-ci est D.
    Est-ce que c’est possible de faire ça ?

    Merci d’avance

  18. Bonjour,
    Est-ce que je pourrais créer par exemple un tableau ayant 100 cases, pour 1000 valeurs ? C’est-à-dire, est-ce que je pourrais faire créer au programme rapidement un tableau ayant les cases : case 0 : valeur 0, case 1 : valeur 10, case 2 : valeur 20, […], case 78 : valeur 780, etc… sans avoir à tout écrire moi-même ?
    Merci d’avance ! (en espérant que la réponse ne se trouve pas quelque part où je ne l’aurais pas vue… 😉 )

  19. Salut Eskimon;
    Merci pour ce tuto très clair, je cherchais des précisions sur les fonctions, et j’ai trouvé ici pas mal de réponses. Il me reste cependant 1 question, si on souhaite afficher le résultat d’une fonction avec par exemple un serial.print, doit on obligatoirement stocker le résultat de la fonction dans une variable avant de pouvoir l’afficher? et pas un truc du style serial.print(MaFonction()) ?
    Merci

  20. Salut,
    Je voulais savoir s’il existe dans le langage Arduino de quoi réaliser des traitements sur la structure des tableaux. Comme concaténer deux tableaux, ou bien récupérer un sous-ensemble d’un tableau, etc.

  21. Pingback: Arduino | Pearltrees

  22. bonjour;
    je voudrais sur un écran lcd faire comme sur un serial et l’analog c’est a dire de remplacer le serial par le lcd mais je n’y arrive pas, quelqu’un aurait une solution svp ?

  23. Bonjour j’ai un exo si je choisie 1 il me passe le double pareil pour 2,3,4 esque le programme est bon

    unsigned char operation = 0;
    int a = 1;
    int x = 2;
    int y = 3;
    int z = 4;
    void setup() {
    // put your setup code here, to run once:
    Serial.begin(9600);
    }

    void loop()
    // put your main code here, to run repeatedly:
    {
    //le paramètre « opération » donne le type d’opération à faire
    maFonction(a,x, y,z, operation);
    }

    int maFonction(int param0,int param1, int param2, int param3,int param4)
    {
    int resultat = 0;
    switch(param4)
    {
    case 0 : //addition, resultat = 15
    resultat = 1 * param0;
    break;
    case 1 : //soustraction, resultat = -5
    resultat = 2 * param1;
    break;
    case 2 : //multiplication, resultat = 50
    resultat = 3 * param2;
    break;
    case 3 : //division, resultat = 0 (car nombre entier)
    resultat = 4 * param3;
    break;
    default :
    resultat = 0;
    break;
    }

    return resultat;
    }

  24. Salut Eskimon , je travaille en ce moment sur la transmission sans fil, je souhaiterai transmettre les données d’un joulemètre en RS232 à un emetteur HF (433 MHZ ou 2.4GHZ) et ensuite retransmettre ces valeurs. Les deux données sont l’énergie et le temps mais j’ai des problèmes de synchronisation dans mes programmes peux-tu y jeter un coup d’oeil

    Programme coté joulemètre
    float energy = 125.354;
    float times = 0.056;

    void setup() {

    Serial.begin(9600);

    }

    void loop() {
    envoiEnergy(energy);
    envoiTime (times);
    delay(1000);
    }

    void envoiEnergy ( float value){
    String buff = «  »;

    char* exc = (char*)(&value);
    char* paquet = new char[4];

    for(int i = 0; i<4; i++){
    for(int j = 0; j<8; j++){
    (exc[3-i] & (1<<(7-j))) ? buff += "1": buff += "0";
    paquet[i] = exc[i];
    }
    buff += " ";
    }

    float energie= *(float*)paquet;

    // Serial.println(buff);
    Serial.println(energie,4);

    }
    void envoiTime ( float value2){
    String buff2 = "";

    char* exc2 = (char*)(&value2);
    char* paquet2 = new char[4];

    for(int i = 0; i<4; i++){
    for(int j = 0; j<8; j++){
    (exc2[3-i] & (1<<(7-j))) ? buff2 += "1": buff2 += "0";
    paquet2[i] = exc2[i];
    }
    buff2 += " ";
    }

    float tps = *(float*)paquet2;

    // Serial.println(buff2);
    Serial.println(tps,4);

    }

  25. ensuite le programme de l’emetteur HF
    #include

    #include

    #include
    ////////////////////////////////////////////////////////
    LiquidCrystal lcd(9,8,5,4,3,2);
    String message = «  »; /* déclaration de variables*/
    char buf;
    float lastVal[2];
    float energy;
    float times;
    //////////////////////////////////////////////////

    void setup() {
    Serial.begin(9600);
    lcd.begin(16,2);
    vw_setup(2400);
    vw_set_tx_pin(12);
    }

    void loop() {
    //Réception du temps et de l’énergie

    if (Serial.available()>0){
    buf = (char)Serial.read();
    message += buf;

    for(int i=0;i<4;i++){

    if(buf == '\n'){
    lastVal[i] = message.toFloat(); //conversion des chaines de caractères en flottant
    message = "";
    Serial.println(lastVal[i],4);
    }

    }

    energy = lastVal[0]; /* attribution des différentes valeurs*/
    times = lastVal[1];
    ///////////////////////////////////////////////////////////////////////
    Serial.print("Energy :");
    Serial.println(energy,4); // affichage avec 4 chiffres après la virgule
    Serial.print("Times :");
    Serial.println(times,4);
    /////////////////////////////////////////////////////////////////////////
    }
    /////////////////////////////////////////////////////

    // Transmission avec l'emetteur HF 433MHZ

    vw_send((byte *) &energy, sizeof(energy)); // On envoie le message
    vw_wait_tx(); //attente de la fin de Transmission
    vw_send((byte *) &times, sizeof(times));
    vw_wait_tx();

    ///////////////////////////////////////////
    lcd.print("Energy ");
    lcd.print(energy,4);
    lcd.setCursor(15,0);
    lcd.print("J");
    lcd.setCursor(0,1);
    lcd.print("Times");
    lcd.setCursor(7,1);
    lcd.print(times,4);
    lcd.home();

    delay(1000);

    }

  26. Et celui-là sera le programme du recepteur , merci de bien vouloir me donner des pistes
    #include

    #include

    ///////////////////////////////////////////////////////////////

    float energy;
    float times;

    //////////////////////////////////////////////////////////////

    LiquidCrystal lcd(8,9,5,4,3,2);

    //int valeurs[6];
    ///////////////////////////////////////////////////////////////
    void setup() {
    Serial.begin(9600);
    ///////////////////////////////////////////////////////////////
    lcd.begin(16,2);
    //////////////////////////////////////////////////////////////
    vw_setup(2400);
    vw_set_rx_pin(11);
    vw_rx_start(); // On peut maintenant recevoir des messages
    /////////////////////////////////////////////////////////////

    Serial.println(« Go ! »);
    }

    void loop() {

    byte taille_message = sizeof(energy);
    byte taille_temps = sizeof(times);

    /////////////////////////////////////////////////////////////////

    // On attend de recevoir un message
    vw_wait_rx();

    vw_get_message((byte *) &energie, &taille_message);

    vw_wait_rx();

    vw_get_message((byte *) &times, &taille_temps);

    /////////////////////////////////////////////////////////////////// Affichage moniteur série !
    Serial.print(energie,4);
    Serial.println(« J »);
    Serial.print(times,4);

    Serial.println();

    ///////////////////////////////////////////////////////////////// Affichage écran lcd !

    //ligne 1
    lcd.print(energie,4);
    lcd.setCursor(13,0);

    lcd.print(« J »);
    lcd.setCursor(0,1);
    lcd.print(times,4);

    delay(1000);
    }

  27. Bonjour, j’essaye actuellement de faire fonctionner un programme via arduino utilisant un potentiomètre.
    Mon problème : je fixe la variable potentiomètre >= à 200
    Donc tant que : potentiomètre>=200
    Alors faire le programme (ici versement d’une boisson selon un certain ordre)
    Or lorsque mon potentiomètre atteint 200 je voudrais pouvoir le faire revenir en arrière mais sur mon programme, il reste bloqué à 200 et donc, on peut verser la boisson autant de fois que voulu ( le potentiomètre représente la quantité de liquide dans le reservoir soit 200= plein donc versement possible sinon versement impossible )
    J’espère avoir été compris ^^ merci d’avance .

Laisser un commentaire