LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

vendredi 24 mars 2017

33 visiteurs en ce moment

Trucs, astuces et choses à ne pas faire !

... en programmation pour votre Arduino

. Par : Dominique

En programmation, personne ne peut se vanter de tout savoir. Il y a des formations, bien-sûr, mais dans notre domaine du modélisme, on a tendance à la négliger un peu pour s’occuper de nos trains avant tout.

Ce site est destiné à vous aider dans votre formation, non seulement par les articles sur la programmation, mais aussi les exemples qui se trouvent dans les réalisations.

Cet article procède différemment : il est destiné à vous faire connaitre une partie de l’expérience d’un grand expert australien de l’Arduino : Nick Gammon qui a rassemblé sur son site, des quantités d’informations utiles, mais en anglais. Il est très présent aussi sur le forum arduino.cc dont il est modérateur d’ailleurs, par la grande qualité de ses contributions.

Cet article se concentre sur une petite partie de son savoir faire : cette page que je vais tenter de traduire pour vous.

Tant qu’on ne les a pas commises, on peut faire des erreurs ! On apprend ainsi "sur le tas". Donc autant en connaitre un maximum pour les éviter.

J’espère que cet article vous fera gagner du temps !!!

Nous allons présenter 2 parties :

  • les erreurs classiques à éviter
  • les trucs et astuces à utiliser

Les erreurs classiques à éviter absolument

Lorsqu’on clique sur le bouton "vérifier", le compilateur vous signale les erreurs qui l’empêchent de produire le code pour votre Arduino.

Mais quand il ne signale pas d’erreur, c’est là qu’il faut se méfier !!

Les erreurs décrites ci-après ne sont pas signalées par le compilateur mais elles empêchent votre Arduino de fonctionner.

ERREUR #1 : Lire trop de données d’un port de communication.

Par port de communication, on entend ici soit le port série (le plus utilisé), soit un port Ethernet ou un port CAN ou I2C, etc...

exemple à ne pas faire :

  1. if (Serial.available ())
  2. {
  3. char a = Serial.read ();
  4. char b = Serial.read ();
  5. }

L’instruction Serial.available () retourne une valeur non-nulle si au moins un caractère est disponible. Mais rien ne permet de savoir s’il y en a 2 ou plus.

Lire 2 caractères est une erreur. A 9600 bps, la transmission d’un caractère dure environ une milliseconde alors que l’instruction Serial.read() s’éxécute en à peine une microseconde. Le 2ème caractère n’est peut-être pas encore arrivé et le résultat est vraiment incertain.

Pour l’éviter il faut tester la disponibilité de chaque caractère dans une boucle while par exemple :

  1. while (Serial.available () > 0)
  2. mon_traitement (Serial.read ());

ERREUR #2 : Tenter de tester un numéro de pin, plutôt que l’état de cette pin.

Cela parait bête, mais ça arrive, exemple :

  1. const byte switchPin = 4;
  2. ...
  3.  
  4. if (switchPin == HIGH)
  5. {
  6. // switch is pressed
  7. }

Le résultat du test sera toujours vrai puisque la valeur 4 est équivalente à HIGH (seul LOW vaut 0).

il faut écrire :

  1. const byte switchPin = 4;
  2. ...
  3.  
  4. if (digitalRead (switchPin) == HIGH)
  5. {
  6. // switch is pressed
  7. }

ERREUR #3 : Confondre "=" (assignation) et "==" (comparaison).

Voilà l’erreur :

  1. if (temperature = 10)

La variable temperature se verra assignée la valeur 10 et le résultat du if sera toujours vrai.

Il faudra écrire :

  1. if (temperature == 10) // comparaison

De façon similaire, ceci est mauvais :

  1. counter == 5;

Il faut écrire :

  1. counter = 5; // assignation

ERREUR #4 : Faire un Serial.print ou un delay dans une routine d’interruption.

Ce code ne peut pas fonctionner :

  1. ISR (TIMER0_OVF_vect)
  2. {
  3. Serial.print ("Timer overflow !");
  4. delay (100);
  5. }

Comme les interruptions sont désactivées pendant l’exécution de la routine ISR, ni la fonction Serial.print(), ni delay() ne peuvent s’exécuter car elle utilisent des interruptions.

D’une manière générale, dans une routine d’interruption, il faut respecter les règles suivantes :

  • y mettre le moins de code possible
  • ne pas utiliser delay ()
  • ne pas utiliser Serial.print ()
  • déclarer "volatile" les variables partagées avec le code principal
  • ne pas activer ou désactiver les interruptions

Vous trouverez plus de détails dans l’article Les interruptions.

ERREUR #5 : Utiliser trop de mémoire RAM.

Déclarer une variable tableau :

  1. int myReadings [2000];

va utiliser 4k octets de RAM (un entier occupe 2 octets).

Le Uno ne dispose que de 2k octets de Ram. Les Arduino à base de 328 sont dans le même cas.

Le symptôme est que le programme va probablement se resetter aussitôt démarré ou s’arrêter carrément.

Un bon moyen de s’assurer qu’il démarre correctement est d’afficher quelque chose sur le moniteur au démarrage, et de préférence le nom de votre programme, sa version et sa date :

  1. // ... toutes les declarations ...
  2. #define VERSION "MonTruc - V0.1 - 19/07/2016"
  3.  
  4. void setup ()
  5. {
  6. Serial.begin (115200);
  7. Serial.println (VERSION);
  8. } // fin du setup

Si vous ne voyez pas s’afficher "MonTruc - V0.1 - 19/07/2016" au démarrage, il y a de bonnes chances que la mémoire RAM soit saturée.
N’oubliez pas que les bibliothèques aussi consomment de la RAM (SD, LCD, I2C, etc).

Vous trouverez plus de détails dans l’article consacré à la bibliothèque MemoryUsage

ERREUR #6 : Incrémenter une variable d’une manière incongrue.

Ceci ne marche pas :

  1. i = i++;

Le résultat est incertain, et certainement pas i+1.

A la place il faut utiliser :

  1. i++;

ou

  1. i = i + 1;

ERREUR #7 : Appeler une fonction en oubliant les parenthèses.

L’erreur à éviter :

  1. void fairebien ()
  2. {
  3. // les instructions de la routine
  4. }
  5.  
  6. void loop ()
  7. {
  8. fairebien; // <-- pas de parentheses (c'est pas bien !)
  9. }

La compilation ne va pas le signaler mais le programme ne marchera pas.

Il faut bien écrire :

  1. void fairebien ()
  2. {
  3. // les instructions de la routine
  4. }
  5.  
  6. void loop ()
  7. {
  8. fairebien (); // <-- avec les parentheses (c'est bien !)
  9. }

ERREUR #8 : Faire plusieurs choses dans un If en oubliant les accolades.

C’est un grand classique :

  1. if (temperature > 40)
  2. digitalWrite (fourControl, LOW);
  3. digitalWrite (warningLight, HIGH);

L’indentation suggère que les 2 instructions qui suivent l’ if y sont attachées.
En réalité, seule la première sera soumise à la condition et la deuxième s’exécutera toujours.

Par précaution, il vaut mieux mettre des accolades, même pour une seule instruction :

  1. if (temperature > 40)
  2. {
  3. digitalWrite (fourControl, LOW);
  4. digitalWrite (warningLight, HIGH);
  5. } // end if temperature > 40

ERREUR #9 : Déborder au delà de la taille maximale d’un tableau.

Un autre grand classique :

  1. int table [5];
  2. table [5] = 42;

Les 5 éléments de table sont indicés 0, 1, 2, 3, 4 mais pas 5 !
L’accès à table [5] se traduira par un écrasement de la mémoire juste après la variable table, avec des résultats inattendus. Cette erreur est difficilement détectable. Le mieux est de relire son code à tête reposée de temps en temps.

ERREUR #10 : Faire des calculs qui dépassent les capacités des variables.

Il ne faut pas croire que l’on peut initialiser un long avec des opérations sur des int :

  1. unsigned long secondesparjour = 60 * 60 * 24;

Le valeurs 60, 60 et 24 sont traitées par le compilateur comme des entiers et le résultat restera toujours inférieur ou égal à 32767.

Il faut écrire :

  1. unsigned long secondesparjour = 60UL * 60 * 24;

Le suffixe "UL" change le type du 60 pour en faire un unsigned long.

ERREUR #11 : Mettre des " ;" à la fin de toutes les lignes.

Après les if, for, while, switch, il ne faut pas mettre de point-virgule " ;"

  1. if (temperature > 40); // <----- ce point-virgule est incorrect !
  2. {
  3. digitalWrite (fourControl, LOW);
  4. digitalWrite (warningLight, HIGH);
  5. }
  6.  
  7. for (int i = 0; i < 10; i++); // <----- ce point-virgule est incorrect !
  8. digitalWrite (i, HIGH);

Le point-virgule termine l’instruction, donc ce qui suit n’est plus soumis à la condition et le programme fonctionne mal.

Il faudrait bien écrire :

  1. if (temperature > 40)
  2. {
  3. digitalWrite (fourControl, LOW);
  4. digitalWrite (warningLight, HIGH);
  5. }
  6.  
  7. for (int i = 0; i < 10; i++)
  8. digitalWrite (i, HIGH);

De la même manière, ceci est une erreur :

  1. #define LED_PIN 10; // <--- pas de ";"
  2. #define LED_PIN = 10; // <--- pas de ";", pas de "="

il faut écrire :

  1. #define LED_PIN 10

ou, mieux :

  1. const byte LED_PIN = 10;

ERREUR #12 : Faire trop joli dans les commentaires .

Ceci est une erreur :

  1. // pour faire un effet de symétrie\\
  2. int butTheCompilerNeverSeesThisDeclaration;

car les "\\" font que la ligne suivante fait partie du commentaire, donc elle n’est pas compilée.

Restons simple et standard :

  1. // ceci est un commentaire standard
  2. int maVariable;

ERREUR #13 : Initialiser plusieurs variables dans une seule ligne.

Exemple :

  1. int x, y, z = 12;

Ici seule la variable z est initialisée à 12.

Il faudrait écrire :

  1. int x = 1, y = 2, z = 12;

ou mieux :

  1. int x = 1;
  2. int y = 2;
  3. int z = 12;

ERREUR #14 : Oublier d’initialiser une variable locale d’une fonction.

Ceci conduit à un problème :

  1. void calculateStuff ()
  2. {
  3. int a;
  4.  
  5. a = a + 1;

Car a n’est pas initialisé et le résultat sera n’importe quoi !

ERREUR #15 : Tenter de positionner plusieurs pins dans une seule instruction.

Ceci est une erreur :

  1. digitalWrite ((8, 9, 10), HIGH);

Car seule la pin 10 sera mise à HIGH.

Il faudrait écrire :

  1. digitalWrite (8, HIGH);
  2. digitalWrite (9, HIGH);
  3. digitalWrite (10, HIGH);

ou

  1. for (byte i = 8; i <= 10; i++)
  2. digitalWrite (i, HIGH);

ERREUR #16 : Oublier un " ;" après un "return".

Attention !

  1. if (a < 10)
  2. return // <----- pas de ";"!
  3. a = a + 1;

Ce code sera compilé comme s’il était écrit :

  1. if (a < 10)
  2. return a = a + 1;

ERREUR #17 : Abuser de la récursivité.

Voilà une erreur spectaculaire :

  1. void loop ()
  2. {
  3. // faire des tas de choses
  4.  
  5. loop (); // <--- recursion!
  6. }

A chaque appel de loop (), la pile est utilisée. Elle sera pleine rapidement et ça plantera !

Ceci aussi est à proscrire, pour revenir à la loop sous certaine condition :

  1. void loop ()
  2. {
  3. foo ();
  4. }
  5.  
  6. void foo ()
  7. {
  8. if (something)
  9. loop ();
  10. }

ERREUR #18 : Utiliser la simple quote ’abcd’ au lieu de la double quote "abcd".

Ceci ne va pas :

  1. char foo = 'start';

il faut écrire :

  1. char foo [] = "start";

Le simple quote ne peut s’utiliser que pour affecter un caractère unique :

  1. char forwardCommand = 'F';

ERREUR #19 : Problème de téléversement sur Mega d’un code contenant " !!!".

Certains programmes d’amorçage (bootloader) sur l’Arduino Mega arrêtent le téléversement lorsqu’ils rencontrent une suite de 3 points d’exclamation " !!!" dans le code :

  1. Serial.println ("Erreur !!!");

La solution est de ne jamais mettre de " !!!" dans votre code ou de mettre à jour le bootloader, notamment en suivant les instructions sur le site de Nick Gammon : bootloader

ERREUR #20 : Réutiliser un Arduino déjà programmé dans une nouvelle configuration matérielle.

Ceci n’est pas vraiment un problème de programmation, mais cela peut détruire un Arduino.
Lorsqu’un projet est fini et qu’un Arduino de test peut être réutilisé sur un autre projet, il faut se méfier du programme qui y est enregistré. En changeant la configuration matérielle autour de cet Arduino, à la prochaine mise sous tension (par l’USB et l’IDE), il peut y avoir des incompatibilités matérielles, en particulier avec les pins programmées en sortie.

Pour éviter cela, le mieux est de charger ce code avant d’installer l’Arduino dans sa nouvelle configuration :

  1. void setup () { }
  2. void loop () { }

Toutes les pins se retrouvent programmées en entrée et aucune mauvaise surprise ne peut arriver.

ERREUR #21 : Ajouter "void" devant un appel de fonction.

Ce code ne fonctionne pas :

  1. void foo ()
  2. {
  3. Serial.println ("Hello, world.");
  4. }
  5.  
  6. void loop()
  7. {
  8. void foo (); // <---- cela n'appelle pas la fonction foo
  9. }

Le mot clé "void" définit une fonction prototype et ne s’utilise QUE à la déclaration de la fonction.

ERREUR #22 : Oublier le mot "case" dans un switch.

Ce code ne fait pas ce qui est attendu :

  1. switch (action)
  2. {
  3. wateringOn:
  4. digitalWrite (wateringPin, ON);
  5. break;
  6.  
  7. wateringOff:
  8. digitalWrite (wateringPin, OFF);
  9. break;
  10. } // end of switch

Il manque les mots-clé "case" :

  1. switch (action)
  2. {
  3. case wateringOn:
  4. digitalWrite (wateringPin, ON);
  5. break;
  6.  
  7. case wateringOff:
  8. digitalWrite (wateringPin, OFF);
  9. break;
  10. } // end of switch

ERREUR #23 : Retourner un pointeur sur une variable locale.

Ceci est une erreur :

  1. char * getString ()
  2. {
  3. char s [] = "abc";
  4. return s;
  5. }

La variable locale s est située dans la pile et elle n’existe que quand la fonction est appelée. Elle n’est donc plus valide au retour de la fonction.

Il vaut mieux écrire :

  1. char * getString ()
  2. {
  3. static char s [] = "abc";
  4. return s;
  5. }

A titre de variante, s peut être déclarée en globale.

ERREUR #24 : Faire un "sscanf" ou "sprintf" sur un float.

Ceci ne marche pas :

  1. float foo;
  2. char buf [] = "123.45";
  3. sscanf (buf, "%f", &foo);

sscanf () ne supporte pas les float sur Arduino !

Ceci ne marche pas non plus :

  1. float foo = 42.56;
  2. char buf [20];
  3. sprintf (buf, "%f", foo);

sprintf () ne supporte pas les float sur Arduino !
A la place on pourra utiliser dtostrf () :

  1. float f = 42.56;
  2. char buf [20];
  3. dtostrf (f, 10, 4, buf); // number, width, decimal places, buffer

ERREUR #25 : Oublier "break" dans un "switch/case".

Exemple :

  1. switch (i) {
  2. case 0: {j = 0;}
  3. case 1 : {j = 1;}
  4. }
  5. Serial.print(" j = ");
  6. Serial.println(j); // <--j vaut toujours 1

En effet, le break ayant été oublié à la fin du case 0, l’exécution continue au cas suivant et on finit par avoir i=1 quelque que soit la valeur de i au départ. C’est bête !

Il faut écrire :

  1. switch (i) {
  2. case 0:
  3. j = 0;
  4. break;
  5. case 1 :
  6. j = 1;
  7. break;
  8. }
  9. Serial.print(" j = ");
  10. Serial.println(j); // là c'est bon

"break" sert aussi à sortir d’une boucle for ou while quand une condition de sortie se réalise.
"continue" permet de terminer le traitement d’une boucle et de sauter au tour suivant. On imagine bien les effets dévastateurs d’un oubli dans ces 2 cas !

ERREUR #26 : Une mauvaise utilisation de "continue".

"continue" permet de terminer le traitement d’une boucle et de revenir au début de la boucle. Dans cet exemple, voyez-vous l’erreur ?

  1. i = 0;
  2. while (i < 10)
  3. {
  4. if (i == 5) continue; // retour au début de la boucle
  5. Serial.print("i = ");
  6. Serial.println(i);
  7. i++;
  8. }

L’erreur vient du fait qu’on retourne au début de la boucle sans avoir incrémenté i : cela devient une boucle infinie, le programme semble figé !

On aurait du écrire :

  1. i = 0;
  2. while (i < 10)
  3. {
  4. if (i++ == 5) continue; // retour au début de la boucle
  5. Serial.print("i = ");
  6. Serial.println(i-1);
  7. }

Dans ce cas i est toujours incrémenté juste après le test mais avant le continue. Et là ça marche. On affiche bien la série de valeurs 0 à 9 sans le 5.

Les trucs et astuces à utiliser de préférence

Après le négatif, voici un peu de positif !

TRUC #1 : Utiliser une table pour une série d’objets similaires .

Par exemple :

  1. int ledPin1 = 3;
  2. int ledPin2 = 4;
  3. int ledPin3 = 5;
  4. int ledPin4 = 6;

Sera avantageusement remplacé par :

  1. const byte ledPin [4] = { 3, 4, 5, 6 };

Comme il s’agit de pins dont les valeurs ne changeront pas on ajoute le mot-clé "const" dans ce cas.

TRUC #2 : Placez vos chaines de caractères en Flash plutôt qu’en RAM .

La déclaration :

  1. Serial.print ("Le programme démarre.");

Se traduit par l’occupation de la RAM par la chaîne "Le programme démarre."

Comme la RAM est rare, on peut faire en sorte de stocker cette chaîne (statique évidemment) en Flash en la préfixant d’un "F" :

  1. Serial.print (F("Program starting."));

TRUC #3 : Mettez vos principaux paramètres en début de programme.

Au lieu de mettre les valeurs en dur dans les instructions :

  1. void setup ()
  2. {
  3. Serial.begin (115200);
  4. pinMode (5, OUTPUT);
  5. digitalWrite (5, LOW);
  6. pinMode (6, OUTPUT);
  7. digitalWrite (6, HIGH);
  8. ...

Vous devriez déclarer ces paramètres regroupés en début de programme pour les modifier plus facilement par la suite :

  1. const unsigned long BAUD_RATE = 115200;
  2. const byte LED_PIN = 5;
  3. const byte MOTOR_PIN = 6;
  4.  
  5. void setup ()
  6. {
  7. Serial.begin (BAUD_RATE);
  8. pinMode (LED_PIN, OUTPUT);
  9. digitalWrite (LED_PIN, LOW);
  10. pinMode (MOTOR_PIN, OUTPUT);
  11. digitalWrite (MOTOR_PIN, HIGH);
  12. ...

Le code ne change pas même si les paramètres changent et vous ne risquez plus d’introduire un coquille !

TRUC #4 : N’utilisez jamais Goto .

Bien que ce soit possible, il faut perdre cette vielle habitude !

Il est toujours possible de s’en passer en utilisant intelligemment les for,  while, do, break, continue et return.

TRUC #5 : Ne cherchez pas à optimiser votre code .

En le rendant obscur et illisible pour les autres.

En revanche, vous devez bien choisir les types de vos variables pour optimiser la place qu’elle prennent en RAM.

Pour mémoire, les limites des variables en fonction des types sont :

  1. char: -128 to +127
  2. byte: 0 to +255
  3. int: -32768 to +32767
  4. unsigned int: 0 to +65535
  5. long: -2147483648 to +2147483647
  6. unsigned long: 0 to +4294967295

TRUC #6 : Faites confiance au compilateur .

Au lieu de faire le calcul vous même :

  1. const unsigned long secondsInDay = 86400; // 60 * 60 * 24

Laissez-le au compilateur :

  1. const unsigned long secondesparjour = 60UL * 60 * 24;

De même, au lieu de vous soucier de la limite dans votre code :

  1. char buffer [20];
  2.  
  3. // plus loin ...
  4.  
  5. if (i < 20)
  6. {
  7. buffer [i] = c;
  8. }

Laissez le compilateur s’en occuper pour vous :

  1. char buffer [20];
  2.  
  3. // plus loin ...
  4.  
  5. if (i < sizeof (buffer))
  6. {
  7. buffer [i] = c;
  8. }

Si vous changez plus tard la taille du buffer, vous n’aurez pas à retoucher tout votre code.

Dans un tableau, plutôt que d’indiquer la taille :

  1. const byte pinNumbers [5] = { 5, 6, 7, 8, 9 };

Faites le faire par le compilateur :

  1. const byte pinNumbers [] = { 5, 6, 7, 8, 9 };

Pour connaitre le nombre d’éléments d’un tableau, avec sizeof, vous pouvez définir une MACRO :

  1. #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

Et voilà comment s’en servir :

  1. int myArray [20];
  2.  
  3. int numberOfItems = ARRAY_SIZE (myArray); // <--- sera = 20 dans ce cas

Attention : il ne faut pas oublier que sizeof ne fonctionnera pas avec un tableau passé en argument dans une fonction (c’est le pointeur qui est passé, pas le tableau). La réponse serait toujours égale à 2 (taille d’un pointeur sur un processeur 8 bits).
Si vous avez besoin de la taille du tableau, il faut aussi la passer dans les arguments.

TRUC #7 : Utiliser Else .

Au lieu d’enchaîner les if :

  1. if (a == 5)
  2. {
  3. // do something
  4. }
  5. if (a != 5)
  6. {
  7. // do something else
  8. }

Il vaut mieux utiliser else :

  1. if (a == 5)
  2. {
  3. // do something
  4. }
  5. else
  6. {
  7. // do something else
  8. }

TRUC #8 : Utiliser switch/case, plutôt qu’une série de if .

A éviter :

  1. if (command == 'A')
  2. {
  3. // do something
  4. }
  5. else if (command == 'B')
  6. {
  7. // do something
  8. }
  9. else if (command == 'C')
  10. {
  11. // do something
  12. }
  13. else
  14. {
  15. // unexpected command
  16. }

Préférez :

  1. switch (command)
  2. {
  3. case 'A':
  4. // do something
  5. break;
  6.  
  7. case 'B':
  8. // do something
  9. break;
  10.  
  11. case 'C':
  12. // do something
  13. break;
  14.  
  15. default:
  16. // unexpected command
  17. break;
  18. } // end of switch

Pour ceux qui peuvent lire l’anglais, je recommande de regarder le reste de la page de Nick qui contient bon nombre d’autres conseils plus adaptés aux "confirmés".

De même, à partir de cette page, je vous conseille de suivre les nombreux liens qu’il donne.

Bonne programmation !

3 Messages

Réagissez à « Trucs, astuces et choses à ne pas faire ! »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if ... else

Instructions conditionnelles : le switch ... case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Le monde des objets (1)

Le monde des objets (2)

Le monde des objets (3)

Le monde des objets (4)

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Les derniers articles

Les Timers (V)


Christian Bézanger

Trucs, astuces et choses à ne pas faire !


Dominique

Le monde des objets (4)


Thierry

Les pointeurs (2)


Thierry

Les chaînes de caractères


Thierry

Transcription d’un programme simple en programmation objet


Dominique, Guillaume, Jean-Luc

Les pointeurs (1)


Thierry

Comment gérer l’aléatoire ?


Dominique, Guillaume, Jean-Luc

Les Timers (IV)


Christian Bézanger

Les fonctions


Jean-Luc

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Comment gérer le temps dans un programme ?

Calculer avec l’Arduino (1)

Répéter des instructions : les boucles

Les Timers (II)

Les chaînes de caractères

Les Timers (IV)

Instructions conditionnelles : le if ... else

Les pointeurs (1)