1. Objectif pédagogique

À la fin de ce cours, vous saurez :

• Comprendre le rôle et les limites de l’EEPROM interne d’un Arduino.
• Lire et écrire des données persistantes avec EEPROM.read() et EEPROM.write().
• Optimiser les écritures avec EEPROM.update().
• Sauvegarder et relire des variables complètes avec EEPROM.put() et EEPROM.get().
• Créer un projet simple qui conserve ses paramètres après extinction.

Précaution à prendre

En quelque minutes les cellules EEPROM peuvent se détérioré et altéré votre carte.

2. Présentation de L'EEPROM

Qu’est‑ce que l’EEPROM ?
L’EEPROM (Electrically Erasable Programmable Read-Only Memory) est une mémoire non volatile : elle garde les données même sans alimentation.

Caractéristiques :

• Capacité limitée : ex. 1024 octets sur un Arduino Uno.
• Accès octet par octet ou via des variables complètes.
• Durée de vie ~100 000 écritures par cellule (éviter les écritures inutiles).

Applications : sauvegarde de paramètres, compteurs, scores, restauration d’état après redémarrage.

3. Matériel nécessaire

• Arduino Uno (ou Nano, Mega…)
• Câble USB
• (Optionnel) Bouton poussoir + résistance 10 kΩ
• (Optionnel) LED + résistance 220 Ω

Schéma minimaliste : pour les premiers exemples, aucun câblage n’est requis.

4. Explication du fonctionnement

L’EEPROM est organisée en cases numérotées (adresses). Chaque case stocke un octet (0–255). Imaginez un meuble avec 1024 tiroirs : chaque tiroir peut contenir un petit papier avec un nombre. Quand vous éteignez l’Arduino, les papiers restent en place.

5. Premier code minimaliste

Exemple simple : écrire puis lire un octet à l’adresse 0.

#include <EEPROM.h>

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

  // Écrire 42 à l'adresse 0
  EEPROM.write(0, 42);

  // Lire la valeur stockée à l'adresse 0
  byte valeur = EEPROM.read(0);

  Serial.print("Valeur lue : ");
  Serial.println(valeur);
}

void loop() {
  // Vide
}

Ce que fait ce code : écrit le nombre 42 à l'adresse 0, puis le relit et l'affiche sur le moniteur série.

6. Décryptage du code

• #include <EEPROM.h> : active la bibliothèque EEPROM.
• EEPROM.write(adresse, valeur) : écrit un octet.
• EEPROM.read(adresse) : lit un octet.
• Les adresses vont de 0 à EEPROM.length()-1.
• Erreur fréquente : écrire trop souvent (surtout dans loop()) use la mémoire.

7. Expérimentation guidée

Propositions faciles :

• Changer la valeur écrite (ex. EEPROM.write(0, 100)).
• Utiliser une autre adresse (ex. adresse 10).
• Écrire plusieurs valeurs et les relire.

8. Fonctions avancées

En complément de read() et write(), Arduino fournit :

EEPROM.update(adresse, valeur)

Écrit seulement si la valeur est différente de celle déjà stockée — utile pour économiser les cycles d'écriture.

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  EEPROM.update(0, 42); // Écrit seulement si nécessaire
  Serial.println("Valeur mise à jour !");
}

void loop() {}

EEPROM.put(adresse, variable)

Permet d'enregistrer une variable complète (int, float, struct...) en une seule instruction.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  info.compteur = 123;
  info.temperature = 24.5;
  EEPROM.put(0, info);
  Serial.println("Données sauvegardées !");
}

void loop() {}

EEPROM.get(adresse, variable)

Lit directement une variable complète depuis l'EEPROM (complément de put).

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  EEPROM.get(0, info);
  Serial.print("Compteur : ");
  Serial.println(info.compteur);
  Serial.print("Température : ");
  Serial.println(info.temperature);
}

void loop() {}

Astuce : put() et get() gèrent automatiquement la taille en octets — attention à la place restante dans l'EEPROM.

9. Vérification avant écriture dans l’EEPROM

Avant d’enregistrer une donnée en mémoire EEPROM, il est essentiel de vérifier que sa valeur a réellement changé. En effet, si la donnée est identique à celle déjà stockée, une réécriture inutile détériorera prématurément la cellule mémoire, qui ne supporte qu’un nombre limité de cycles d’écriture. Pour protéger la durée de vie de l’EEPROM, il faut donc ajouter systématiquement une étape de vérification avant d’écrire.

Voici un exemple fiable et simple, utilisable pour tout type de donnée basique (comme un octet) :

#include <EEPROM.h>

int adresse = 0;         // Adresse mémoire EEPROM
byte nouvelleValeur = 42; // Valeur à écrire

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

  // Lire la valeur actuelle dans l’EEPROM
  byte ancienneValeur = EEPROM.read(adresse);

  // Vérifier si la valeur a changé avant d’écrire
  if (ancienneValeur != nouvelleValeur) {
    EEPROM.write(adresse, nouvelleValeur);
    Serial.println("Valeur mise à jour dans l’EEPROM.");
  } else {
    Serial.println("Valeur identique, écriture évitée pour préserver l’EEPROM.");
  }
}

void loop() {
  // Rien ici
}

Cette méthode simple protège efficacement l’EEPROM contre les écritures redondantes et prolonge sa durée de vie.

Exemple fiable de vérification avant écriture avec EEPROM.get() et EEPROM.put()

Pour éviter d’écrire inutilement dans l’EEPROM une structure Donnees, on peut comparer la donnée à écrire avec celle déjà stockée, puis n’écrire que si elles diffèrent.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees infoNew;  // Nouvelle donnée à sauvegarder
Donnees infoOld;  // Donnée lue depuis EEPROM

void setup() {
  Serial.begin(9600);
  delay(1000); // Attente pour le moniteur série

  // Initialisation des nouvelles données
  infoNew.compteur = 123;
  infoNew.temperature = 24.5;

  // Lire la donnée existante dans EEPROM à l'adresse 0
  EEPROM.get(0, infoOld);

  // Comparer byte à byte pour vérifier si les données ont changé
  if (memcmp(&infoNew, &infoOld, sizeof(Donnees)) != 0) {
    EEPROM.put(0, infoNew);
    Serial.println("Données mises à jour dans l’EEPROM.");
  } else {
    Serial.println("Données identiques, écriture évitée.");
  }
}

void loop() {
  // Rien ici
}

10. Résumé

• Lecture/écriture d'octets : read() / write().
• Éviter les écritures inutiles : update().
• Stocker/charger des variables complètes : put() / get().
• Penser à la taille disponible et à l'usure des cellules.

Ressources complémentaires

• Documentation officielle : arduino.cc — EEPROM
• Bibliothèque EEPROM.h incluse par défaut
• Conseil pratique : limiter les écritures inutiles pour préserver la mémoire

Cet article La persistance des données EEPROM est apparu en premier sur PlaisirArduino.

Caractéristiques du ruban à LED adressage

Type: WS2812B

Alimentation: 18 mA/LED 5V ne supporte pas les surtensions, une alimentation stable est recommandée.

La bibliothèque de gestion des LEDs que j'ai utilisée est "Adafruit_NeoPixel.h".

Le projet est relativement simple à mettre en oeuvre sur un petit nombre de LEDs. J'ai pris comme point de départ l'exemple "simple" que j'ai retravaillé.

La bibliothèque Adafruit NeoPixel pour Arduino est conçue pour faciliter la gestion des LED RGB individuelles ou des bandes de LED RGB, telles que les populaires LED WS2812 ou WS2812B. Voici quelques-unes des fonctions natives de cette bibliothèque :

1. Adafruit_NeoPixel pixels(nombre de pixels, branche de sortie, neoPixelType type)

• Initialise la bibliothèque en spécifiant le nombre total de pixels, le numéro de broche à laquelle les pixels sont connectés et le type de pixels (par exemple, NEO_GRB ou NEO_RGB).

1. begin()

• Initialise la communication avec les pixels. Cette fonction doit être appelée une fois dans le programme, généralement dans la fonction setup().

1. show()

• Envoie les données de couleur aux pixels. Vous devez appeler cette fonction après avoir modifié les couleurs des pixels pour les rendre effectives.

1. setPixelColor(numéro de la LED adressable, couleur rouge de 0 à 255, couleur vert de 0 à 255, <strong><code>couleur bleu de 0 à 255)

• Définit la couleur d'un pixel spécifique en spécifiant les valeurs des composants rouge, vert et bleu (RVB). Les valeurs des composants RVB vont de 0 à 255.

1. setPixelColor(uint16_t n, uint32_t color)

• Version alternative de setPixelColor où vous spécifiez directement la couleur sous forme d'un entier 32 bits, où les 8 premiers bits représentent le rouge, les 8 suivants le vert et les 8 derniers le bleu.

1. setBrightness(intensité de 0 à 255)

• Ajuste la luminosité de tous les pixels. La valeur de luminosité varie de 0 (éteint) à 255 (pleine luminosité).

1. Color(uint8_t red, uint8_t green, uint8_t blue)

• Fonction utilitaire qui renvoie une couleur sous forme d'entier 32 bits à partir des composants RVB spécifiés.

1. ColorHSV(uint16_t hue, uint8_t saturation, uint8_t value)

• Fonction utilitaire qui renvoie une couleur sous forme d'entier 32 bits à partir des composants HSV (teinte, saturation, valeur) spécifiés.

1. getPixelColor(uint16_t n)

• Récupère la couleur d'un pixel spécifique sous forme d'entier 32 bits.

1. clear()
   • Éteint tous les pixels en les mettant à la couleur noire (0, 0, 0).

Ces fonctions de base devraient vous aider à démarrer avec la gestion des LEDs à l'aide de la bibliothèque Adafruit NeoPixel dans vos projets Arduino. N'oubliez pas de consulter la documentation officielle pour des détails plus approfondis sur chaque fonction : https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library.

Merci pour votre intérêt, vous pouvez revoir toutes les vidéos sur la chaine Youtube plaisirarduino

Cet article Ruban à l’LED adressable est apparu en premier sur PlaisirArduino.

La bibliothèque est incontournable dans l'univers Arduino pour l'exploitation de multiple composants ou la gestion de communication entre composants et l'Arduino. Vous avez sûrement déjà utilisé <<LiquidCrystal.h>> pour un afficheur LCD ou <<Servo.h>> pour des servomoteurs et <<SPI.h>> pour le traitement de la communication SPI. Mais, il y en a bien d'autres.

Avant toute chose , il faut préalablement installer puis inclure la bibliothèque dans notre programme.

Tout comme vous, à mes débuts, je me suis fié aux divers exemples trouvés dans l'IDE ou sur le net sans me demander pourquoi et comment on utilisait les bibliothèques. Puis avec l'expérience, je me suis documenté et me suis aperçu que je n'exploitais qu'à moitié certaines bibliothèques alors qu'elles me proposaient d'autres possibilités intéressantes.

C'est pour cela donc, que dans ce tutoriel, nous allons apprendre à "lire" une bibliothèque et identifier ce dont il nous faut pour son exploitation optimale.

Nous explorerons la bibliothèque <<Servo.h>> pour nos exemples.

De quoi est composé une bibliothèque ?

En fait, c'est un dossier. Il contient des dossiers et fichiers de code programme. Il y a principalement trois fichiers et un dossier à explorer.

• Le fichier d'entête. Repérable par ".h"
• Le fichier sources. Repérable par ".cpp"
• Le dossier "exemple". Qui contient des codes sources en exemple d'utilisation.
• Le fichier de syntaxe des couleurs. Qui contient les consignes de couleurs à appliquer pour chaque type de mots-clés.

Ici, nous nous concentrerons particulièrement sur le fichier d'entête, Puis nous verrons le fichier "exemple" et "syntaxe".

Comment explorer une bibliothèque ?

Tout d'abord, commencez par rechercher et trouver le fichier d'entête de la bibliothèque qui est en l’occurrence pour nos exemples "Servo.h".

Deux solutions pour trouver ce fichier.

Première solution.

Exécutez une recherche de fichiers depuis le menu "DÉMARRER" en tapant "Servo.h".  Ensuite, ouvrez-le et suivez les étapes 5 et 6 de la solution suivante.

Deuxième solution.

1. Premièrement, si vous n'avez pas modifié son emplacement par défaut à l'installation, allez sur vôtre disque local "C:" dans le dossier "programme files".
2. Ensuite, ouvrez le dossier "Arduino"
3. Puis, le dossier "libraries".
4. Après, le dossier "Servo".
5. Ouvrir le dossier "src".
6. Finalement, le fichier "Servo.h" apparaît.

Explorons le fichier.

Une fois que vous avez trouvé l'emplacement du fichier "Servo.h", ouvrez-le.

A première vue, on a pas l'impression que ce fichier est un code programme car il est présenté sous format" texte". De ce fait, il est exploitable par un éditeur de texte comme "NotePad", "WordPad" ou le "Bloc-notes".

De toute évidence, vous constaterez qu'il est en anglais. Donc pour cette étape, un travail de traduction des commentaires sera très utile à la compréhension du programme. Je vous invite donc à le faire avec un traducteur de votre choix.

Ne surtout pas apporter de modifications à ce document! Surtout si vous n'avez pas d'idée précise de ce que vous faite. Alors dans ce cas, ne JAMAIS accepter d'enregistrer des modifications car cela entraînerait le dysfonctionnement de la bibliothèque et provoquerait des erreurs lors du téléversement.

Mais quel est son rôle ?

le rôle du fichier d'entête.

Le rôle du fichier d'en-tête est de mettre en place la structure principale de la bibliothèque. Il informe le compilateur de tout ce qu'il lui faut pour exécuter la bibliothèque et va en quelque sorte s'occuper de "déclarer". Il n'y a pas d'exécution de fonctions, ces dernières se font dans le fichier source ".cpp".

On dit qu'il contient le prototype de la bibliothèque.

 Clairement,  nous avons découpé le fichier en plusieurs parties.

• La présentation.
• L'inclusion.
• La déclaration.
• La classe.

Les grandes parties du fichier d'entête ".h"

1) La présentation.

En somme, après traduction, elle vous indique la version, le ou les auteurs, ainsi que les conditions générales d'utilisation (GNU). C'est obligatoire et recommandé pour la distribution.

Il faut aussi souligner que ce texte est un commentaire balisé par ceci  "/* */" ce qui vous permet d'identifier la première partie de la présentation générale.

Ensuite, vous avez une seconde partie. L’aspect le plus important de cette partie, c'est qu'elle décrit le fonctionnement globale de la bibliothèque.

Cependant, toutes les bibliothèques ne le font pas. Dans celle-ci sont citées et mentionnées avec un descriptif, toutes les méthodes, dont vous avez besoin pour exploiter vos programmes. Nous y viendrons en détail par la suite.

Après la présentation, poursuivons à présent, vers le code programme qui s'en suit.

2) L'inclusion.

Voyons tout d'abord, les lignes du code ci-dessous.

Les deux premières lignes permettent au compilateur l'inclusion de la bibliothèque dans votre projet. La troisième ligne quand à elle inclue au sein même de la bibliothèque une autre bibliothèque.

Par contre, "ifndef" signifie en anglais "if not defined" soit en français "si n'est pas défini". Nous avons donc là une condition "if". Cette condition permet lors de la compilation d'un programme de ne pas systématiquement la compiler. On trouve ici un exemple important, à savoir, que l'on a une compilation conditionnelle des bibliothèques.

Par conséquent, suite à notre condition d’exécution, il faut bien-sûr indiquer au compilateur quoi exécuter !!

Cela ce fait avec l'instruction #endif. "endif" qui signifie en français "fin de si". On comprend que la condition d'exécution s’arrête là. On trouve cette instruction à la fin du fichier d'entête.

J'attire votre attention sur le fait que tout le programme du fichier d'entête est contenu dans ces instructions. Vous le constaterez en explorant le fichier.

Poursuivons vers la partie suivante.

Celle-ci fait appel aux versions d'Arduino utilisées AVR SAM ou SAMD. Effectivement, il existe plusieurs versions possibles de compilations. De ce fait, le compilateur doit donc être capable de s'adapter aux divers environnements d'exploitation proposés. Mais là aussi, nous n’approfondirons pas. Sachez juste que cette partie définie votre environnement de travail pour adapter le travail du compilateur.

Vous avez sans doute remarqué les instructions suivantes. #if defined pour si définis, #elif defined pour si non définis, #else pour sinon et finalement #endif pour fin de if. Vous l'avez compris, c'est un ensemble d’instructions conditionnelles en fonction des versions possibles.

3) Les déclarations.

A ce niveau du programme, nous avons deux parties distinctes. Les variables et la classe. Nous décomposerons donc cette partie en deux et nous ignorerons celle encadrée en noir qui nous est étrangère.  Les commentaires ont été traduit pour une approche plus compréhensible.

3.1) Les variables.

En premier lieu, nous avons les déclarations de variables utiles au traitement de tout programme. A cette étape de notre exemple, on intègre une donnée à chaque variable.

3.2) La classe.

Finalement, nous voici dans la "déclaration" de ce que l'on appelle une classe.

L'instruction "class" et son bloc d'instructions "{ }" permet de nommer et de créer une classe. Dans notre exemple ci-dessous elle est nommée Servo.

class Servo { Bloc d'instructions à exécuter }; // Déclaration d'une classe.

Une fois nommée, la classe permettra d'initialiser un objet auquel elle sera rattachée pour que ce dernier puisse faire appel au constructeur et aux méthodes qu'elle contient.
Cela étant dit une classe peut être aussi utilisée sans objet.

Examinez l'illustration ci-dessous.

Notamment, il y a deux parties très importantes de la "classe". La partie "public:" et "private:". En français public et privé. Mais en fait leur véritable nom est modificateurs d'accès. Comme le nom l'indique, ils conditionnent l'accès ou non à certaines instructions utilisées à l’intérieur de la classe.

Public permet aux utilisateurs au travers de l'IDE d’accéder aux instructions qui lui sont confiées. Par contre private interdit l'accès aux instructions qui lui sont confiées.

Observons ensuite la partie public. Nous avons, le constructeur.

3.2.1) Le Constructeur.

Vous le reconnaîtrez par le fait qu'il porte le nom de la classe suivi de parenthèses (comme pour un appel de fonction) et qu'il est placé juste après l'instruction "public:". Notez que, dans notre exemple ci-dessus, il ne possède aucun paramètre.

Contrairement à notre exemple "servo", il est possible que dans d'autres librairies, vous trouviez plusieurs constructeurs qui portent le même nom. Si vous observez (entre parenthèses) vous constaterez que ces librairies n'ont pas toutes les mêmes types ou nombres de paramètres. Néanmoins, le compilateur est capable de faire la différence et de ce fait, il laisse aux utilisateurs la possibilité de configurer le projet de différentes manières en fonction du type ou du nombre de données renseigné.

Prenons pour exemple la bibliothèque <<LiquidCrystal.h>> et observez ci-dessous les différences.

Nous avons quatre méthodes paramétrables toutes différentes l'une de l'autre. Ces dernières nous indiquent le type et le nombre de données à utiliser pour chaque paramètre. Les paramètres ont également été nommés? ce qui n'est pas toujours le cas.

Mais à quoi sert le constructeur ?

Le constructeur permet aux utilisateurs de renseigner et configurer un objet qui lui est rattaché avec des données externes. Voyez l'exemple ci-dessous.

Ci-dessus LiquidCrystal est notre classe puis nous avons créé un objet "lcd" et indiqué en paramètre le numéro des broches utilisées pour exploiter note afficheur LCD.

Voici ce que cela donne à l'IDE avec la bibliothèque Servo.

On retrouve notre classe "Servo" et notre objet "mon_servo". Notamment, il n'y a pas de paramètres à renseigner car il n'a pas été déclaré pour cela.

En déclarant notre objet, nous pouvons à présent depuis l'IDE faire appel à ce qui suit, c'est-à-dire les méthodes.

3.2.2) Les méthodes.

Les méthodes sont en réalité des fonctions nommées méthodes pour les identifier comme appartenant à une bibliothèque et les différencier des fonctions classiques que l'on peut créer dans nos programmes. Elles aussi peuvent être paramétrées ou non. A cette étape du programme, nous avons la déclaration des méthodes. Un type et un nom symbolique sont attribués à la méthode et à ses paramètres. Exactement comme on le ferait pour une fonction.

type nomSymbolique (type nomSymbolique ) ;

uint8_t attach (int pin); // attache la broche donnée au canal libre suivant, définit pinMode, renvoie le numéro de canal ou 0 si défaut.

Notez l'absence des accolades et des instructions aux méthodes. En effet, comme nous l'avons dit plus haut le fichier ".h" s'occupe principalement de la déclaration. La partie "exécutive" étant exécutée dans le fichier source ".cpp". Dans notre exemple (ci-dessus encadré en bleu), nous avons là toutes les méthodes utiles pour exploiter un servomoteur.

Finalement, pour toutes bibliothèques si vous cherchez les méthodes, dont vous avez besoin, c'est à cet endroit que vous les trouverez. Certes, il ne vous est pas nécessaire de connaître leur programmation mais seulement leur utilité.

Les exemples.

Dans la plupart des bibliothèques les méthodes sont expliquées avec des commentaires. Mais dans certain cas, cela n'est pas fait. Heureusement dans ces cas là, les éditeurs intègrent toujours des exemples d'exploitation à leurs bibliothèques. A travers les exemples, vous trouverez les commentaires sur l'utilisation de chaque méthode.

C'est pourquoi vous trouverez dans le dossier de chaque bibliothèque, un dossier nommé "examples". Toutefois, il n'est pas utile de passer par le dossier mais de simplement lancer l'exemple depuis l'IDE en cliquant sur "Fichier" ensuite sélectionnez "Exemple" puis le nom de la bibliothèque que l'on souhaite exploiter.

Les mises en forme

Cela à titre d'information. Quand vous utilisez une bibliothèque, la classe et les méthodes s'affichent à l'IDE en orange. C'est fait pour signaler leur utilisation dans un fichier de bibliothèque et vous assurer que vous l'avez bien orthographié. Aussi de cette façon, si vous déclarez, par hasard, une variable qui porte le même nom qu'une méthode utilisée dans l'une des bibliothèque incluse à votre programme; cette variable changera de couleur vous indiquant par conséquent qu'elle ne peut pas être utilisée comme telle.

Ce jeu de couleur est appliqué dans un fichier nommé "Keywords.txt".

Voici ce qu'il contient:

En fait, ici sont regroupés des mots-clés en deux catégories de format de couleurs. Le premier "KEYWORD1" et le second "KEYWORD2". Évidemment, les mots-clés choisis sont ceux utilisés pour les méthodes de la classe Servo.

• KEYWORD1 applique un caractère gras et la couleur orange  aux mots-clés.
• KEYWORD2 applique seulement la couleur orange aux mots-clés.

Il vous sera utile de connaître ce fichier le jour où vous créerez vous-même vos bibliothèques. Ce qui sera un sujet bientôt abordé.

Vous savez à présent comment explorer le fichier "H" et comment identifier les méthodes utiles pour l'exploitation d'une bibliothèque. Amusez-vous à explorer les autres bibliothèques pour en comprendre le fonctionnement.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article Bibliothèque, comment l’explorer ? est apparu en premier sur PlaisirArduino.

Tout d’abord que veut dire LCD ? LCD est l'abréviation du terme anglais "Liquid Crystal Display" qui signifie en français  "Écran à cristaux liquides". D’où afficheur LCD.

L'afficheur LCD est en particulier une interface visuelle entre un système (projet) et l'homme (utilisateur). Son rôle est de transmettre les informations utiles d'un système à un utilisateur. Il affichera donc des données susceptibles d'être exploiter par l'utilisateur d'un système.

Nous utiliserons le modèle 1602A (V2.0) que l'on trouve dans le kit Arduino (2012).

Comprendre l'afficheur

Pour commencer nous détaillerons le datasheet  de l 'afficheur 1602A (V2.0). C' est un document fourni par le constructeur dans lequel est détaillé ses caractéristiques, son fonctionnement et ses différentes utilisations possibles. Il est une source de renseignements très utile pour la maîtrise de son exploitation. Les datasheet sont, pour la plupart, en anglais. Aidez vous de Google traduction pour les traduire.

1 - Les caractéristiques.

La première information à connaître est le nombre de caractère affichable par ligne. Pour ce modèle, c'est 16 caractères sur deux lignes soit au total 32 caractères. De toute évidence, on retrouve cette information dans le datasheet sous la forme 16 X 02. Mais aussi dans la référence 1602 A.

On recueille également l'information du mode de  transmission de données sur quatre (4) ou huit (8) bits.

En outre, les informations suivantes à connaître sont les tensions d'exploitations, caractéristiques électriques et mécaniques de l'afficheur LCD.

2 - Le brochage.

Le tableau ci-dessous représente bien le rôle de chaque broche et définit le brochage de l'afficheur LCD .

• Premièrement, les broches 1, 2 et 3 sont dédiées à l'alimentation. La broche 1 et 2 pour l'alimentation générale. La broche 3 pour le branchement d'un potentiomètre qui contrôle le contraste de l'afficheur.
• Deuxièmement, les broches 4, 5 et 6 pour le pilotage de la transmission des données. Elles pilotent l'écriture ou la lecture de données.
• Troisièmement, les broches de 7 à 14  pour le transfert des données elles-mêmes.
• Et pour finir, les broches 15 et 16 pour l'alimentation du rétro-éclairage.

Grâce à ces informations nous connaissons le brochage de l'afficheur. De plus nous avons en appui un schéma de raccordement.

Ce schéma illustre bien les branchements de l'alimentation principale et de ces auxiliaires. Nous avons ajouté le repérage des broches. Il y a une erreur signalée en rouge. Ne pas câbler ce fil.

Nous avons donc maintenant suffisamment d'informations pour brancher l'afficheur LCD en toute confiance.

3 - Les branchements de l'afficheur LCD.

A présent que tout est en place. Comment l'activer et le piloter? De toute évidence? il nous faudra lui envoyer des données . Mais quelles données envoyer et comment ?

4 - La transmissions de données.

Observez le schéma ci-dessous. Nous avons ajouté le brochage suivant les repères du tableau. De plus, vous constaterez bien-sûr, la représentation de deux "modules". Le ST7066U et le ST7065C.

Le ST7066U et le ST7065C sont des puces électronique utilisées en particulier pour piloter des matrices d'afficheurs LCD et capables de piloter 40 segments respectivement. Comme, par exemple, un MAX7219 avec une matrice à LED 8X8.

En effet l'afficheur est composé de plusieurs matrices chacune d'elle indépendante. Ci-contre la représentation d'une matrice affichant le caractère "A".

En définitive, il y a 32 matrices de cinq points sur huit (5X8) disposés sur deux lignes qui composent l'afficheur représenté ci-dessous.

En fait, les pilotes reçoivent les données, les interprètent et affichent les caractères voulus aux positions souhaitées. Mais pour cela, il faut leur transmettre des données.

D'ailleurs, les deux logigrammes de transmission de données ci-dessous. L'un Writing data pour la réception de données  et l'autre Reading data pour la transmission de données. Cependant, la seule chose qui diffère entre ces deux diagrammes, c'est l'état à la broche "RW" en rouge.

Ainsi, on comprend qu'en fonction de l'état "Haut" ou "Bas" à la broche "RW", le pilote de la matrice ST7066U est en mode de réception ou émission de données.

Il n'y aura pas d'émission de données, la broche R/W sera donc par défaut à l'état bas "LOW" et par conséquent branché au 0V.

5-Les instructions de données.

Comment transmettre des données à l'afficheur LCD?

Le tableau ci-dessous regroupe les diverses instructions de pilotage de l'afficheur.

D'autan plus qu'à la suite du tableau, il y a un descriptif de ces instructions.

Donc pour ceux qui veulent plus de détails, à titre d'information téléchargez la traduction, en français, du datasheet. Il faut reconnaître que malgré les termes non définis, cela vous sera plus facile de comprendre toutes les données utiles pour piloter l'afficheur LCD.

Pour transmettre ces données, il faut maîtriser le protocole de transmission de données entre l'Arduino et l'afficheur LCD. Créer une fonction de transfert de données et pour le moment, c'est hors de notre portée. Pour ces raisons, et heureusement pour nous, des programmeurs ont conçu ces fonctions. Nous n'avons donc plus qu'à les exploiter pour mettre en service l'afficheur.

Note: dans le jargon de programmeur les fonctions dont on parle sont normalement appelées des méthodes .

6-Les fonctions de la bibliothèque.

Des programmeurs ont créé des méthodes qui nous permettent d'exploiter l'afficheur. D'ailleurs, par simplicité et plus de flexibilité, ils les ont installé dans une bibliothèque appelée <LiquidCristal.h>.

Ces méthodes, nous les avons bien évidemment  extraites en explorant le fichier d'en-tête de la bibliothèque <LiquidCristal.h>. Vous trouverez comment le faire au travers du tutoriel intitulé  <<Explorer une bibliothèque et découvrir ses méthodes>>.

Ci-dessous un tableau des méthodes de <LiquidCristal.h>

Nom de fonction.	Rôles.
void clear();	Efface l'afficheur.
void home();	Retourne le curseur au point d'origine (0,0).
void noDisplay();	Désactive l'affichage.
void display();	Active l'affichage.
void noBlink();	Désactive le clignotement du curseur.
void blink();	Active le clignotement du curseur.
void noCursor();	Désactive le curseur.
void cursor();	Active le curseur.
void scrollDisplayLeft	Décale l'affichage vers la gauche.
void scrollDisplayRight();	Décale l'affichage vers la droite.
void leftToRight();	Déplace le curseur vers la droite à l'affichage d'une donnée.
void rightToLeft();	Déplace le curseur vers la gauche à l'affichage d'une donnée.
void autoscroll();	Active le défilement automatique de l'affichage vers la gauche.
void noAutoscroll();	Désactive le défilement automatique de l'affichage vers la gauche.
void createChar(uint8_t, uint8_t[]);	Permet l'appel de caractères ou symboles pré- construit dans un tableau.
void setCursor(uint8_t, uint8_t);	Place le curseur à la position souhaitée.
void setRowOffsets(int row1, int row2, int row3, int row4)	?
virtual size_t write(uint8_t);	?
void command(uint8_t);	?

Pour utiliser les méthodes d'une bibliothèque, il faut avant toute chose l'inclure dans le programme  par l'instruction #include <bibliothèque.h> .

Une fois incluses, nous pouvons commencer la programmation.

Mais avant de commencer,  il va falloir initialiser et configurer l'afficheur. Sans cela impossible d'utiliser les méthodes .

7-Initialisation, configuration et test de l'afficheur LCD.

L'initialisation.

Premièrement, il faut donc initialiser l'Arduino en fonction des besoins de l'afficheur. Cela consiste à attribuer aux broches de l’Arduino des tâches de travail en fonction des broches de l'afficheur.

Étant donné que c'est une initialisation, elle s'effectue en tête de programme par l'appel de la classe LiquidCrystal et en lui attribuant un OBJET. On dit ici faire une instanciation. Comme illustré ci-dessous "lcd" est l'objet. (Vous pouvez lui donner le nom de votre choix.)

Néanmoins, vous constaterez que l'attribution d'un objet ne suffit pas. Il faut également attribuer des données préalablement déclarées. Ces données consistent à initialiser les broches. (Vous pouvez aussi bien ne pas les déclarer et utiliser le numéro de broche).

Il faut souligner que l'ordre de chaque donnée a son utilité et son importance. Elles correspondent particulièrement à un traitement bien défini car elles seront traitées pour exécuter une tâche bien précise.

• RS : Donnée de broches qui synchronise les données.
• E : Donnée de broches qui active la réception des données.
• D4, D5, D6, Et D7 ; Données de broches qui transmettent les données.

Ci-dessous un exemple de déclaration des broches en fonction de notre exemple.

Nous sommes en mode transmission de données quatre bits, délivrée en quartet, soit quatre bits via les broches 2,3,4 et 5. Les broches 12 et 11 pilotent le transfert des données. Nous pourrions utiliser huit bits (plus rapide) mais quatre bits (plus simple) suffiront largement.

La configuration.

Une fois initialisée,  il faut configurer le LCD dans le setup() grâce à la méthode begin() en rattachant son objet "lcd" et en la paramétrant.

Ci-dessus la première donnée (16) est le nombre de colonne et la seconde (2) le nombre de ligne. Nous pouvons à présent mettre en service l'afficheur pour le tester.

Le test.

Pour tester l'afficheur nous utiliserons donc la méthode print(); que nous connaissons déjà. Comme illustré ci-dessous ne pas oublier de placer le message entre guillemets.

L'affichage du message confirmera alors le bon branchement et le fonctionnement de l'afficheur. Passons donc à l'étape de l'exploitation.

8-L'exploitation de l'afficheur.

Ensuite pour exploiter l'afficheur LCD,  il suffit de faire appel aux autres méthode de la bibliothèque. Vous trouverez aussi des exemples de programmes fournis avec la bibliothèque.

En effet, dans le menu de l'IDE. Via FICHIER => EXEMPLE => LiquidCrystal => tous les exemples d'exploitation possibles.

L'ensemble des méthodes est utilisé dans les exemples. Pour cette raison, nous ne détaillerons pas l'exploitation des méthodes car les exemples sont simples à comprendre.  Reportez-vous au tableau des méthodes plus haut dans  le chapitre six " Les fonctions de la bibliothèque".

Vous savez à présent de quoi se compose un afficheur LCD et comment le mettre en service. Apprenez et amusez-vous à manipuler et modifier les exemples selon vos besoins de programmation de vos projets. Aidez-vous des traducteurs pour les traduire.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article L’afficheur LCD. Qu’est ce que c’est ? est apparu en premier sur PlaisirArduino.

Introduction

Au travers de ce tutoriel, nous allons exploiter un signal analogique en entrée pour piloter en sortie PMW dit MLI en français Modulation de Largeur d'Impulsion.

Le but est de faire varier la luminosité d'une LED en agissant sur un potentiomètre. Pour cela nous allons utiliser:

• Une carte Adruino UNO.
• Un potentiomètre de 10Kohm.
• Une résistance de charge de 220ohm.
• Une LED de couleur rouge.

Pour comprendre la gestion PWM, il faut tout d’abord faire un petit rappel. Vous découvrirez plus de détail, en cliquant ici.

Les branchements.

Commençons par examiner la platine Arduino UNO :

• Nous avons 12 broches configurables en entrées ou sorties repérées de 2 à 13. Seules les broches PMW repérées avec ce symbole "~" configurées en sorties modulerons une longueur d'impulsion numérique MLI calculée sur une résolution numérique de 8bits qui représente une plage de 0 à 255 points de mesure. Ce procédé simule un signal de sortie analogique mais qui en fait n'en n'est pas un. Donc nous utiliserons la broche 3, repéré par le sigle "~" (PMW).
• Il y a également 6 broches d'entrées, repérées de A0 à A5, spécifiquement conçues pour le traitement des signaux de tensions analogiques allant jusqu'à 5V max. Elles exploitent un convertisseur analogique/numérique d'une résolution numérique de 10 BITS qui représentent une plage de 0 à 1023 points de mesure. C'est pour cela que nous utiliserons l'une de ces broches pour raccorder notre potentiomètre, à l'occurrence A0.

Ne surtout pas dépasser la tension de 5V max si celle-ci est externe à la carte Arduino.

Le programme.

Déclarations.

En premier lieu, nous déclarons nos variables.

Configurations.

Nous établissons ensuite nos configurations.

• Pour un retour visuel des valeurs exploitées au moniteur série, nous paramétrons la Vitesse du port série.
• Nous configurons en mode sortie la broche utile au pilotage de la LED.

NOTE: il faut souligner qu'il n'est pas nécessaire de configurer une broche d'entrée analogique quant elle est utilisée pour ce type de signal.

Test.

Pour s'assurer que tout fonctionne correctement, il faut tester nos configurations et nos équipements Cela évite de chercher un bogue dans le  programme alors que c'est l'équipement qui est en cause.

Premièrement nous testons la LED. Nous l'activons trois fois pour la contrôler visuellement.

Deuxièmement, pour contrôler le potentiomètre nous utilisons la fonctions analogRead (); qui lit la valeur de tension à la broche sélectionnée et la convertit en chiffre entier de 0 à 1023, puis nous positionnons le potentiomètre en butée mini (gauche) ou maxi (droite)  et effectuons une lecture de notre signal à l'un de ces deux points.  On teste ensuite que la valeur lue correspond bien à 0 (mini) ou à 1023 (maxi) à l'un de ces deux points. Si ce n'est pas le cas, il y a un problème de branchements.

analogRead(Broche à lire);  //Ou variable affectée à la broche.

Vous constaterez l'utilisation de while(1) dans le test qui stoppera l'évolution du programme. En effet dans le cas ou un défaut de lecture est vrais lors du test il faudra donc relancer le programme par un re-set sur la platine ou un téléversement.

Note: Dans ce programme, nous n'avons pas d'initialisation à effectuer.

Programme principal.

Nous décomposons le programme principal en quatre parties.

1. La déclaration des variables locales.
2. L'acquisition du signal.
3. Le traitement du signal.
4. L'exploitation du signal.

Déclarations.

Acquisitions.

Ensuite, nous réalisons la lecture de la valeur du potentiomètre par la fonction analogRead(); et chargeons la valeur acquise dans la variable de traitement  (V.T.)  "val_potar" .

Traitement des signaux.

Une fois la valeur chargée, nous pouvons la manipuler. A cette étape nous allons convertir, mettre à l'échelle et limiter les signaux.

Conversion

Tout d'abord, pour une exploitation plus parlante de notre projet au travers du moniteur série, il est utile de connaître la valeur de tension équivalente de la donnée brute. En d'autres termes, convertir la donnée brute en volt.

• Donc nous allons diviser la tension de service aux bornes du potentiomètre par le nombre de points de lecture. Soit 5Volts divisés 1024 points. Ce qui nous donne un coefficient "K" de conversion que l'on applique par multiples à notre donnée brute. (48.82*10e-3). Après cela nous connaissons théoriquement la valeur de tension appliquée à l'entrée analogique.

Note: Par ailleurs, vous pouvez vous brancher en parallèle au signal de sortie du potentiomètre un appareil de mesure. Néanmoins, des écarts sont à noter et à corriger si nécessaire.

La tension de service est la tension maximum qui sera appliquée à l'entrée analogique.

Ne surtout pas dépasser la tension de 5V maxi si celle-ci est externe à la carte Arduino.

Mise à l'échelle.

Ensuite, il va nous falloir réaliser une concordance entre le signal d'entrée et de sortie. Malgré cela, elles n’ont pas la même échelle de mesure car un signal PWM en sortie est de 255 points et que le signal analogique d'entrée est de 1024 points.

• La fonction map(); nous aide à réaliser une mise à l'échelle du signal d'entrée avec le signal de sortie. De sorte que nous obtenons une corrélation entre le signal d'entrée et de sortie.

map (VT* , mini VT, maxi VT, mini VS*, maxi VS); //Format de la fonction.

*VT = Variable de traitement *VS = Variable de Sortie.

Nous obtiendrons donc 255 points en sortie pour 1023 point en lecture d'entrée.

Limitation.

Certains projets ont des butées mécaniques de fonctionnement qu'il ne faut surtout pas atteindre par risque de casse ou blocage.  Par conséquent, il ne faut pas dépasser certaines valeurs de pilotage en sortie. C'est pour cela que nous utilisons la fonction  constrain(); qui nous aide à effectuer cette opération.

Toutefois, constrain de l'anglais veux dire LIMITER. Nous réalisons donc par cette fonction une mise en butée du pilotage électrique.

constrain(*VT, mini , maxi ); // *VT Variable de traitement.

CONSEIL: Nous pouvons appliquer cette limitation à deux endroits du programme. Soit au signal d'entrée ou au signal de sortie. Il est sécurisant de le faire en sortie car une erreur de traitement (calcul) de la valeur du signal dans le programme  peut avoir des valeurs non acceptables pour vos projets.

Les valeurs de limitations du signal de sortie se détermine par des relevés ou des calculs effectués par vos soins et en connaissance du projet.

La mise en butée du signal d'entrée peut aussi être directement réalisé dans la fonction  map(); avec les paramètres de sorties mini et maxi.

Conversion

Pour les même raison que le signal analogique d'entrée, il nous est utile de connaître la valeur en tension équivalente à la donnée brute d'exploitation en sortie. Nous opérons une conversion comme décrit plus haut mais avec une résolution de 255 points.

• Il faut également diviser la tension de service aux bornes du potentiomètre par le nombre de points de résolution de lecture. Soit 5 Volts divisés par 255 points. Cela nous donne un coefficient "K" de conversion que l'on applique par multiples à notre donnée brute de sortie. (195.3*10e-3).
  Grâce à cela nous connaissons théoriquement la valeur de tension appliquée à la sortie pour le  pilotage.

L'exploitation

Finalement, une fois le signal traité, nous l’intégrons à la fonction  analogWrite(); pour appliquer la consigne de pilotage.

La LED s'allume en fonction de la valeur traitée.

En conclusion, nous constatons que la valeur de tension appliquée à la LED ne dépassera pas les 4,10V. Le signal de sortie étant mis en butée mini et maxi, la valeur de sortie n'atteindra jamais 0V et 5V. Nous voyons ci-dessous le résultat du traitement signal par le moniteur série.

Si l'on voulait, nous pourrions même limiter la tension de pilotage à 2V pour se passer de la résistance de charge de la LED.

Vous connaissez à présent les bases et quelques outils utiles pour l'exploitation d'un signal analogique en entrée et modulé en sortie.

Découvrez et exploitez le signal analogique en téléchargeant les sketchs référents de ce sujet.

++ Petit plus ce programme exemple n'est pas visuellement confortable pour une exploitation via le moniteur série. C'est pour cela que nous vous proposons aussi un programme évolué "Signale_analogique_EVO" de cet exemple qui n'affiche que la valeur actualisée lors d'un changement de valeur au potentiomètre. Vous le trouverez dans la rubrique téléchargement.++.

MERCI.

PlaisirArduino/tutoriel.

FIN.

Cet article Analogique et MLI. Gestion de ces signaux est apparu en premier sur PlaisirArduino.

Description.

Dans l'univers Arduino, vous rencontrerez les LIBRARIES , que l'on appelle bibliothèques . Certaines sont intégrées d'origine au sein du compilateur mais il est aussi possible d'en ajouter en les téléchargeant sur Internet.

Mais en réalité, c'est un sous-programme qui forme un groupement de fonctions utiles à l'exploitation d'équipements comme les servomoteurs, les afficheurs LCD ou gérer des communications SPI et autres composants électroniques.

Charger une bibliothèque.

Il vous sera parfois nécessaire d'installer une librairie qui ne fait pas partie de la liste. Tout d'abord, il vous faudra la télécharger sous format ZIP sur Internet.

Prenons l'exemple de <RTClib.h> utile à la gestion des temps horaires coordonnés pour avoir l'heure exacte. Après avoir recherché et trouvé un site ou télécharger la bibliothèque.

1. D’abord, téléchargez la en format ZIP dans un ficher de destination de votre choix. Nous prendrons "Téléchargement" par défaut.
2. Vous lancez ensuite votre compilateur et ouvrez le menu "croquis", sélectionner "inclure une bibliothèque". Puis la fenêtre déroulante s'ouvre. Cliquez sur " Ajoutez une bibliothèque ZIP".
3. L'explorateur de fichiers s'ouvre. Sélectionnez et ouvrez votre dossier de destination en l’occurrence pour nous "Téléchargement". Recherché le fichier ZIP appelé RTClib et cliquez dessus.
4. Vous retournerez systématiquement au compilateur et constaterez la confirmation du chargement.

Finalement, vous avez installé RTClib.h dans la librairie du compilateur.

Il ne vous reste plus qu'a l'installer dans vos programmes. A l'opposé des originales, celle-ci se trouve dans une seconde liste appelé "Contributed bibliothèque". Il y a aussi une autre liste "Recommended bibliothèque".

Note: Vous retrouverez aussi les fichiers source (.h) des bibliothèques dans le fichier d'installation "Arduino" dans programme files dans le fichier "libraries". Prenez garde à ne pas les modifier si vous ne maîtrisez pas la programmation car il serait endommagé et plus du tout utilisable.

Faire appel à une bibliothèque.

Pour  faire appel à une bibliothèque, il faut aller la chercher dans le menu du compilateur   "croquis" =>>"inclure une bibliothèque" comme illustré ci-dessous.

Vous y retrouverez toutes les bibliothèques incluses dans le compilateur Arduino. Il suffit de cliquer sur l'une d'elle pour installer la directive d'inclusion dans notre programme.

Exemple:

#include de l'anglais veut dire inclure en français c'est la directive d'inclusion . Ce terme ordonne au compilateur de traiter le contenu d'un fichier de la bibliothèque spécifié à son nom, comme s'il faisait partie du programme principal.

La directive d'inclusion se présente sous cette forme  #include <nomDeLaBibliothèque.h>.

Il ne faut pas oublier que pour que le compilateur trouve la bibliothèque à inclure, il faut lui spécifier un chemin d'accès nommé entre  < > guillemets. Le compilateur recherchera les termes du fichier entre guillemets.

Le .h spécifie le type de fichier. H vient du terme anglais Header qui veut dire entête. C'est donc pour spécifier un fichier dit d'entête.

Le but étant ici de savoir comment les mettre en place, nous ne rentrerons pas dans les détails sur leurs constructions car cela sera abordé dans un autre tutoriel.

Vous connaissez à présent la marche à suivre pour installer les bibliothèques de votre choix dans vos projets.

Merci.

Plaisir.Arduino.fr

FIN.

Cet article Bibliothèque, comment l’installer ? est apparu en premier sur PlaisirArduino.

Qu'est-ce qu'une fonction?

Pour commencer, vous avez déjà, peut-être sans le savoir, exploiter une fonction. Les fonctions exécutent des tâches de travail pour lesquelles elles sont dédiées. Prenons le cas de setup() et loop() qui ont pour tâche d'exécuter les instructions contenues dans leurs blocs {}. Plus précisément,  loop() a pour tâche de réitérer en boucle l'exécution des instructions et setup() de les exécuter une seule fois.

Bien évidemment, vous savez que loop(){} est la fonction principale du programme à l’intérieur de laquelle, nous utilisons d'autres fonctions.

Il y a bien sûr les fonctions pré-définies dans L'IDE telles que for(), switch(), ou digitalWrite(); que nous utilisons souvent.

N'oublions pas non plus, les classes qui ont aussi des "fonctions" accessibles depuis l'IDE comme par exemple la classe Serial et sa fonction begin() qui permet de configurer le port série Serial.begin();

Et pour finir, les fonctions pré-définies par les bibliothèques comme par exemple <Servo.h> qui nous apporte au travers des objets qui leurs sont rattachés des fonctions comme par exemple servo.write(paramètres);  ici "servo" est notre objet et il utilise la fonction write();

Nous comprenons ainsi qu'elles sont utiles pour l'exécution de tâches répétitives et évitent alors la réécriture des lignes de codes à chaque fois que se présente une tâche.

Mais l'aspect le plus important d'une fonction lorsque l'on fait appelle à elle, c'est que nous attendons un retour de résultat à la fin de son accomplissement.

De plus, il vous est possible de réaliser des fonctions qui vous sont propres. Il existe différentes façons de les construire! C'est cela que nous allons voir! Comment les construire et quelles sont  leurs particularités !

Un peu de patience !

Comment se construit une fonction?

Elle se présente sous cette forme.

Type de fonction Nom de la fonction (paramètre1,paramètre2, ..., ) { Bloc d'instruction de la fonction} //Format d'une fonction.

Nous voyons ci-dessus qu'il faut définir un type à nos fonctions.

Que veut dire void ?  Cela veut dire "vide" et signifie qu'une fonction de ce  type ne renvoie aucune valeur. Elle sont dites muettes. Patientez un peu, pour en savoir plus sur le renvoi des valeurs nous l'aborderons plus tard.

Il est courant de trouver void entre les parenthèses d'une fonction pour simplement dans ce cas indiquer qu'elle n'a aucun paramètre.  type fonction (void); .

Pour en revenir au  type d'une fonction, il dépendra de la valeur attendue par vous, c'est à vous de le définir. Une fonction typée  int renverra systématiquement une valeur de ce type. Par défaut, le programme renverra en type int.

Exemples de type de fonction .

Notre exemple ci-dessus, illustre également qu'il faut donner un nom symbolique à une fonction. Dans notre exemple c'est "fonction" mais pour une fonction que vous créerez vous-même, c'est à vous de choisir le nom le plus judicieux rattaché à son utilité.

Parlons à présent des paramètres contenus entre parenthèses ! Ils définissent par leurs valeurs le résultat attendu par le traitement de la fonction. Voici un exemple.

Vous constatez qu'il faut également indiquer un type à nos paramètres. Ils seront utiles et exploités dans le bloc {} de la fonction pour exécuter sa tâche. Le bloc est la zone de traitement des instructions qui y seront inscrites. Dans ce bloc, vous pouvez déclarer des variables qui seront locales à notre fonction.

Maintenant que l'on connaît la construction d'une fonction, on peut passer à son exploitation et à son utilisation.

Comment déclarer et appeler une fonction ?

Tout d'abord, pour la créer, comme une variable, une fonction doit être "déclarée". Son appel doit être possible à tout moment de notre programme et vous comprendrez qu'elle soit déclarée de façon globale.

C'est-à- dire que cela se fera en dehors de la fonction loop() et de toutes autres fonctions. L'emplacement avant ou après est possible, c'est à vous d'adopter celle qui vous convient. De préférence et par clarté de lecture programme nous préférons les placer après la fonction loop().

Nous y voici ! Créons notre première fonction! Nous l’appellerons "fonction".

Déclarer sa fonction.

D'abord "Déclarons" , après la boucle loop() notre fonction en type void et sans paramètres. Enfin, nous lui  donnons comme instruction d'envoyer un message au moniteur série.

Comme on pouvait s'y attendre...!  Si vous tentez de téléverser le programme; à ce stade il ne se passera rien! Effectivement,  une fonction doit être appelée pour qu'elle s’exécute. On dit faire appel de la fonction et cela se passe dans le programme principal loop().

Appeler sa fonction.

Il faut tout d'abord connaître de quelle manière on l'appelle. Il suffit d'inscrire le nom de la fonction suivi de ses parenthèses "()" et ponctuer d'un point virgule ";" dans le bloc {} de la fonction loop(). Pour être plus précis, ci-dessous un schéma d'appel de la fonction.

Voir l' exemple ci-dessous.

Notez que nous utiliserons while(1); pour une lecture plus confortable au moniteur série. Vous pouvez maintenant téléverser le programme et voir le résultat.

La fonction s’exécute, c'est déjà un bon début ! Voyons maintenant comment l'exploiter!

Comment exploiter une fonction?

Retour de fonction.

Bien évidemment, vous attendrez de ces dernières qu'elles vous renvoient le résultat de leur travail pour ensuite l'exploiter. Pour récupérer et manipuler la donnée d'une fonction après l'avoir appelé, il va nous falloir une variable pour la stocker.

L'aspect le plus spécifique du retour de fonction est qu'il doit être ordonné par une instruction qui s’appelle return(); .

return(Paramètre de retour); //Instruction de renvoi de données.

Dans un premier temps, commençons par examiner notre fonction. Il va nous falloir une valeur à retourner, ce qui implique une variable qui la contienne. Puis, nous l'intégrerons comme paramètre à return().

En second temps,  déclarons une variable pour stocker le retour de la fonction puis affichons le résultat de cette valeur au moniteur série.

Malgré cela vous allez constater, lors du téléversement, que le résultat est une erreur signalée par le compilateur.

Valeur nulle car elle devrait être ignorée. Voilà ce que nous dit le compilateur. 

Comme nous l'avons dit en début de tutoriel, une fonction de type void ne peut pas retourner de valeur . D'autres messages apparaissent plus bas qui nous indiquent qu'une fonction void ne peut pas accepter le terme return(); car inadapté pour une fonction qui n'est pas faite (typée) pour renvoyer une valeur.

En conclusion, une fonction de type void ne fait qu’exécuter des instructions comme la fonction void loop().

Exploiter une fonction.

Enfin nous y voici !!! Pour qu'une fonction nous retourne une valeur, il va nous falloir lui attribuer un type autre que void. Le type int par exemple est le plus simple pour commencer et comprendre le principe. En conséquence, nous modifions le type de notre fonction par int. Puis, on regarde le résultat au moniteur !!

Tout se déroule comme prévu. La fonction s’exécute et nous retourne sa valeur de retour.

Mais, en réalité, il existe un moyen plus simple d'exploiter le retour des fonctions. Plus précisément,  il n'est pas utile dans tous les cas d'utiliser une variable de stockage. Par exemple, pour afficher la valeur de retour au moniteur, il suffit de l'inscrire comme paramètre à la fonction print();. Inspectez ci-dessous la variante de notre programme d'origine.

Après cela vous constaterez qu'avec moins de ligne; le programme devient plus simplifié et surtout, nous sommes à présent capable d'obtenir le retour d'une fonction.

Comment créer une fonction paramétrée?

Un aspect plus spécifique des fonctions est de pouvoir admettre des valeurs extérieures à elles-mêmes par le biais de leurs paramètres dit formels. Elle vont ensuite nous retourner une donnée finale en fonction des valeurs données en paramètres exploités dans leurs blocs.

Ça y est nous y sommes !!

Premièrement, déclarons les paramètres entre les parenthèses "()" de la fonction en leur spécifiant un type de données. De toute évidence, cela se fera dans la partie "déclarative" de la fonction.

Exemple:

Ci-dessus, nous avons déclaré trois variables de type int .

Mais que faire de nos paramètres au sein de la fonction ? Et bien? ce que l'on en veut ! On peut  les additionner, les soustraire ou autres. On peut aussi les utiliser dans un conditionnement if(). Nous constatons ici que la fonction est un sous programme.

Tout d'abord, il faut comprendre que les paramètres sont utiles pour intégrer à volonté des valeurs extérieures à la fonction. Ces derniers sont renseignés depuis le programme principal de façon "Manuelle ou Systématique", via des variables.

Au travers des fonctions standards de l'IDE, vous savez déjà renseigner des fonctions de façon manuelle donc nous passerons de suite à la manière Systématique. Pour notre exemple, nous ferons un calcul simple.

Comment utiliser les paramètres ?

L'exploitation des paramètres se fera depuis le programme principal et avant toutes choses nous créons trois variables qui contiendront les valeurs (données) à manipuler. Puis nous intégrons ces variables en  paramètres à notre fonction. Comme ci-dessous.

Voici le résultat ! Amusez-vous à changer les valeurs dans les variables !

Bravo !

A partir de là, vous commencerez à penser à vos programmes d'une façon différente. Il faut s'imaginer que votre programme et comme une poupée russe.

NOTE D'EXPLOITATION:

• Il faut savoir que lorsque l'on crée une fonction paramétrée, les variables affectées au paramètres doivent avoir des noms symboliques à leurs exploitations. Prenons le cas de notre exemple, si le premier paramètre est un coefficient, il est judicieux de lui donner un nom du genre "coef". Notre exemple illustre bien que si l'on inverse les variables, le résultat ne sera pas le même. L'utilisation de plusieurs paramètres demande donc une certaine organisation.
• Bien sûr, il est tout à fait possible -et vous serez tenté- de créer des retours de fonctions en utilisant des variables globales mais cette méthode vous demandera un appel systématique de ces dernières, à chaque besoin et de prendre garde de ne pas vous emmêler les pinceaux avec la multitudes de variables que vous pourrez en "sortir". Par principe de clarté logique et à juste titre par return(), nous partons du principe qu'une fonction n'a de retour qu'une seule donnée utile.

Une fonction pour une fonction !

L'utilisation d'une fonction comme paramètre est également possible. Là, on entre dans une dimension autre ! Etant donné qu'une fonction retourne une donnée, cette dernière peut être exploitée par un paramètre. Je vous invite à faire l'essai avec l'exemple ci-dessous. Remarquez que nous l'avons déjà fait avec la fonction de Serial.println();

Le résultat est le suivant. Nous retrouvons alors trois fonctions imbriquées les unes dans les autres par leurs appels. Le principe de poupée russe devient parlant maintenant.

Une fonction tentaculaire !

Imaginez ce que vous pourrez faire à l'aide d'un tableau et de vos paramètres !! Considérons, par exemple, que notre fonction gère trois éléments différents. En supposant que chaque élément possède un tableau de données qui lui est propre.

Notre fonction va traiter et attribuer une valeur à chaque élément en fonction de ces données propres. Prenons notre fonction de base et essayons!

Nous avons de ce fait, répété trois fois la même action pour trois éléments différents de données différentes. Et le résultat est évidemment différent.

A condition de bien s'organiser, cela ouvre des possibilités sans limites. Nous pourrions aller plus loin en créant un programme qui générerait automatiquement les données du tableau de chaque éléments par l'acquisition de signaux d'entrées analogiques ou autres, transmise à des variables propres à chaque tableau. Voyez ci-dessous une ébauche de ce que cela pourrait donner. Nous vous laissons l'exercice de créer des variables de votre cru pour exploiter cette solution. A vous de jouer !!

Vous connaissez à présent  les bases et les outils utiles pour comprendre, créer et exploiter vos propres fonctions. Nous vous invitons à télécharger les sketchs référents à ce tutoriel pour une mise en pratique.

Merci.

PlaisirArduino.fr

FIN.

Cet article Fonctions, comment créer et utiliser les fonctions ? est apparu en premier sur PlaisirArduino.

Ma définition: switch de l'anglais veux dire en français commutateur, changer ou aiguiller. Et case de l'anglais veux dire cas qui exprime ce qui doit arriver si des condition sont réunis pour sa réalisation.

Comme cela nous le dit switch va nous permettre de commuter ou changer de choix en l'aiguillant en fonction des cas proposés. Cette instruction nous autorise donc à des choix multiples structurellement simple contrairement à if qui ne nous offre que deux choix possibles et demande des imbrications multiples plus trop illisibles pour arriver au même résultat.

En premier lieu switch case a besoins que l'on utilise l'instruction break; (vue dans while) à chaque fin de cas pour sortir de sont bloc d'instructions. Sans cela switch exécutera toute les instructions de cas contenu dans son bloc en partant de la sélection active.

switch case possède une particularité. Grâce l'instruction default: qui veut dire défaut en français switch case peut agir par défaut et exécuter des actions spécifiques et définis si aucuns de ses cas n'est réalisés. Si vous n'en avez pas l'utilité Il n'est pas nécessaire de l'utiliser dans le bloc. default: est une option.

Sa construction

Elle est construite en trois parties:

• l'instruction qui contient entre parentes une variable de contrôle utile à l'exploitation de switch.
• Un bloc dans le quel sont réunis les cas d’exécutions définis par la valeur de la une donnée qui lui est attribuée. On la nommera ici donnée sélective. On  y trouvera aussi default: qui n'a pas de donnée sélective.
• Les instructions programmée pour chaque cas de case suivis de l'instruction break;.

Elle se présente sous cette forme.

switch (Variable de contrôle) { case donnée sélective : instructions programmées; break};

Exemple:

Son fonctionnement

Dans l'exemple ci dessus lorsque la variable de contrôle "var" serra égale à la l'une des donnée sélective de case soit 0, 1 ou 2 le programme affichera sa valeur et sortira du bloc switch. Si ce n'est pas le cas on exécute l'instruction default: pour afficher un message.

Le regroupement de données sélectives.

Néanmoins il existe une autre manière d'utiliser les données sélectives de case. Il est possible de regrouper plusieurs données sélectives pour exécuter qu'une seul instruction. Ainsi cela nous donne la possibilité de d’exécuter une instruction avec plusieurs cas.

Exemple:

Dans l'exemple ci dessus les cas de données sélectives impaire et paire sont regroupé pour exécuter l'instruction qui les suit. Il n'est donc pas utile de réitéré l'instruction pour chaque cas si ces dernier ont pour but de réaliser la même action.

Utilisation d'un type char.

La variable de contrôle doit être généralement de type int mais il est possible d'utiliser le type char avec switch case. Donc il suffit de crée une variable ce type et de renseigner les cas de la même manière.

Exemple.

Pour conclure avec l’exemple ci dessus. il  exécutera les instructions de cas en fonction de la variable "lettre".

FIN.

Vous connaissez à présent les bases de switch case. 

Il y de multiple façons d'exploiter  switch () { case:  }; . Vous en découvrirez au fur et à mesure de votre progression et par la mise en pratique de vos projet.

Découvrez switch case en téléchargeant les sketchs référents de ce sujet. Merci.

Cet article switch() { case: } est apparu en premier sur PlaisirArduino.

Introduction.

Pour commencer il se nomme "moniteur série" car il utilise la communication dit "série" entre votre "PC" et votre carte Arduino qui sont connectés via leurs ports "USB".

Tout d’abord, il faut dire que le moniteur série est un outil indispensable pour les tests de programmes. Il est utile pour avoir un retour de données et ainsi nous permet de déboguer les dysfonctionnements de nos programmes par des affichages séquencés des données utiles au traitement du bogue.

La communication série.

Pour ne pas entrer dans les détails de la communication série. C'est un mode de transmission (protocole)  bit à bit des données sur deux conducteurs l'un RX (Réception) et l'autre TX (Transmission). L' essentiel à savoir de la communication série est son débit en bauds car il peut être différent d'un périphérique à un autre. Je dirai  simplement que le bauds est une unité de mesure de débit qui correspond au nombre de bits transmis par seconde. Par exemple si nous avons 800 bauds, il y a 800 bits à la seconde. Il nous sera très utile de connaître son débit en bauds pour l'exploitation du moniteur avec la carte Arduino.

Où l'activer ?

Il est représenté par une loupe et se trouve  dans la barre d'outils en haut à droite du compilateur.

Nous voyons apparaître une fenêtre.

Comment se présente le moniteur ?

Commençons par examiner plus en détaille cette fenêtre dans laquelle apparaissent plusieurs commandes et deux zones blanches d'exploitation.

• Premièrement La grande zone au centre est la zone d'affichage des données reçues par le moniteur.
• Deuxièmement La petite zone rectangulaire, en haut est une zone de saisie et bien-sûr le bouton Envoyer qui se trouve à sa droite permet la commande d'envoi des données saisies. On peut à l'aide du moniteur série envoyer des données vers l'Arduino qui s'occupera de les traiter grâce à la commande spécifique.

Troisièmement La case cochée "Défilement automatique" permet d’arrêter le défilement des données retournées par l'Arduino si on la décoche.

Quatrièmement Le bouton de gauche en bas permet le réglage du mode de défilement des informations via une liste déroulante de choix.

Finalement Le bouton de droite en bas  affiche une liste déroulante de choix qui va nous permettre de choisir la vitesse de transmission de notre moniteur série. Voyez comme les choix sont multiples et en unité bauds.

Ensuite Une fois lancé, le moniteur doit être configuré. On doit lui attribuer un débit de traitement , en bauds, pour qu'il soit synchronisé à la même vitesse que l'Arduino.

Comment synchroniser tout ça ?

Avant toute chose le moniteur série et la carte Arduino ont besoin d’être renseigné et de connaître la vitesse à laquelle ils vont travailler si les deux périphériques n'ont pas le même débit (vitesse) ils ne se comprendront pas.

En premier lieu cela dépend du choix de l'utilisateur.

Ce choix se fait à deux endroits. Dans le "PC" par le moniteur série lui-même et dans la carte Arduino via le compilateur. Tout ceci est dû à une horloge qui synchronise et fixe une cadence de traitement et d'envoi des données. C'est la raison pour laquelle Les valeurs doivent être identiques.

Imaginons par exemples une chaîne de production de deux machines "A et B" qui emballent dans des cartons un produit X. La machine "A" met le produit X dans les cartons et la machine B ferme le carton. La machine "A" met 1 produit par minute dans un carton et la machine "B" ferme 1 carton par minute. Jusque là,  pas de problème, mais si j'augmente la cadence de la machine "A" à 2 produits par minute, Comme on pouvait s'y attendre il va se produire une saturation devant la machine "B" et par conséquent les cartons se retrouveront coincés, tomberont (être ignorés) et ne serons jamais fermés (lus). Pour notre synchronisation, c'est à peu près la même chose. Les deux périphériques doivent travailler à la même vitesse.

Configuration du moniteur série (IDE).

D'abord commençons par le moniteur série qui est plus directement accessible. C'est à nous de choisir et de définir le débit en bauds que l'on souhaite utiliser, donc il suffit donc de le sélectionner dans la liste déroulante qui se trouve en bas à droite du moniteur. A partir de là, nous avons configuré le débit de traitement du moniteur qui est en soit celle du "PC".

Comment configurer la vitesse de travail de l'Arduino?

Tout se passe dans le compilateur ou plus exactement lors de la configuration de notre programme dans la fonction setup().

Avant propos: Les classes.

Il faut tout d’abord savoir qu'il existe ce que l'on appelle des Classes (que nous verrons mais bien plus tard). On distingue une Classe par la majuscule postée en début de mot. la caractéristique principale d'une Classe est de regrouper des fonctions spécifiques à un travail donné. Pour les plus avertis sur le sujet, celle-ci n'a pas besoin d’être appelée en déclaration pour que l'on puisse l'utiliser.

Une Classe est comme une caisse à outils dans laquelle je vais chercher l'outil dont j'ai besoins, une fonction qui a une tâche définie et qu'il me faut. Le tournevis ou la clé à molette ont des fonctions différentes. Vous découvrirez qu’il existe pas mal de grosses caisses et toutes avec des fonctions différentes à l’intérieur.

Pour notre configuration nous aurons besoins en particulier de la classe nommé Serial. qui contient toutes les fonctions utiles à la gestion d'un port série. son travail est de gérer le traitement des données d'une communication série entre le moniteur série et le périphérique Arduino.

Les fonctions de la classe Serial.

Ci-dessous vous avez les fonctions utiles à l'exploitation de la Classe Serial.

Çà en fait des outils !! Il y a de quoi faire du bon boulot!

• begin(); Permet de configurer la vitesse de transmission du port série.
• print(); Permet d'envoyer une donnée vers le moniteur série.
• println(); Permet d'envoyer une donnée vers le moniteur série et fait un saut à la ligne "ln"
• write(); Permet d'exploiter le format binaire, renvoie une chaîne de caractères en nombre de bits
• read(); Permet de lire les données contenues dans le buffer
• flush(); Permet de vider la mémoire tampon, la file d'attente, ou dit le "buffer" de la liaison série.
• available(); Permet de connaître si il y a des caractères disponibles pour lecture dans la mémoire tampon (buffer) du port série.

Dan notre cas celle qui en particulier nous intéresse c'est begin(),

La configuration de la carte Arduino.

La fonction  begin(); permet la configuration de la vitesse de transmission en bauds.

Elle se présente sous cette forme:

• Serial.begin(Paramètre de configuration); //Configuration de vitesse de transmission série.

Le liens d'appel de "begin" avec Serial est fait par le point entre les deux mots, il est appelé en langage C membre de structure.

Parce que c'est une configuration, elle doit être appelée et paramétré à l'intérieur de la fonction "void setup()".

Ci dessous vous trouvez un exemple d'appel de cette fonction au travers de sa classe. le port série de la carte Arduino est configuré à 9600 bauds.

Ainsi nous avons configuré la vitesse de notre port série au même niveau de la carte Arduino.

Finalement notre moniteur est prêt à être utilisé ! Il ne reste donc plus qu'à créer le programme qui lui envoie des données à afficher.

Recevoir des données au moniteur série.

Cette fois ci il nous faudra donc une fonction qui transmet nos données vers le moniteur série. De nouveau nous ferons appel à la classe Serial mais cette fois ci avec la fonction print() qui permet d'envoyer les données souhaitées.

Elle se présente sous cette forme:

• Serial.print( Donnée à afficher); // Affichage d'une donnée au moniteur série.

La fonction print() de Serial nous permet d'afficher deux types de données. Les numériques et alphabétiques . mais aussi des phrases complètes. Mais pour cela il nous faudra les différencier.

La différence de ces deux types de données se ferra dans l'emploie des guillemets "  " dans les parenthèse de la fonction. les guillemets permettent à la fonction print() d'identifier une chaîne de caractères en d’autres termes une phrase. C'est pour cela que dès lors que nous avons besoins d'afficher une phrase au moniteur il nous faudra l'encadrer de guillemets dans les parenthèses de la fonction. Tandis que pour les valeurs numériques brut ou les varaibles cela ne sera pas inutile. Voyez l'exemple ci dessous.

L'exemple ci dessus nous donne les base de l'envoie de donnée vers le moniteur.

 Envoyer des données depuis le moniteur.

Le moniteur série ne sert pas seulement à recevoir des données, il peut également en envoyer. C'est pour cela que nous avons un bouton de commande "envoyer" avec une zone de saisie de données.

Une autre Classe nous sera nécessaire pour l'exploitation du moniteur série et pour l'envoi de phrases appelées des chaînes de caractères alphabétiques. C'est la classe String qui veut dire "chaîne" en français. De même que Serial la classe String englobe des fonctions particulières, utiles aux traitements des chaînes de caractères.

Par contre pour exploiter la classe string, il nous faut lui affecter un dit "objet". Plusieurs "objets" peuvent être affectés à une classe. On appelle ça une instanciation.

Cela se présente de cette manière:Par contre les guillemets sont laissés vides pour accueillir une chaîne de caractères (phrases) transmise par le moniteur série.

"maPhrase" est notre objet. Vous remarquerez aussi qu'il n'est pas utile de placer un point entre l'objet et la classe; contrairement à Serial.

Un objet, c'est un peu comme une variable mais pas vraiment. Cet objet contiendra la donnée à exploiter mais ne sera exploitable que par le biais de la Classe et de ses fonctions incluses.

Les fonctions de la classe String.

Voici ci-dessous les différentes fonctions de String.

• trim() Supprime les espaces dit des « blancs » au début et à la fin d'une chaîne de caractères.
• concat() Rassemble (concatène) deux objets String en un seul dans un nouvel objet String.
• compareTo() Compare deux Objets String.
• toLowerCase() Retourne en minuscules la chaîne de caractères d'un objet String.
• toUpperCase() Retourne en majuscules la chaîne de caractères d'un objet String.
• setCharAt() Modifie un caractère d'un objet String.
• charAt() Retourne à un caractère précis de l'objet String.
• endsWith() Contrôle qu'un objet String se termine ou pas avec des caractères d'un autre objet String.
• equals() Contrôle la similarité de deux objets String. En prenant en compte le format.
• equalsIgnoreCase() Compare la similarité de deux objets String sans prendre en compte le format.
• getBytes() Pointe dans un tableau interne les caractères utilisés pour stocker les caractères d'un objet String.
• indexOf() Localise un caractère ou un String dans un autre objet String
• lastIndexOf() Localise un caractère ou un String dans un autre objet String
• length() Renvoie la longueur de la chaîne d'un objet String, en nombre de caractères
• replace() La fonction replace() de la classe String pour permet de remplacer toutes les instances d'un caractère donné par un autre caractère.
• startsWith() Teste si un objet String commence avec les caractères d'un autre objet String.
• substring() Extrait une sous-chaîne d'un objet String.
• toCharArray() Copie les caractères d'un objet String dans un tableau de caractères (char).

FIN.

Nous vous invitons à découvrir plus en détail le moniteur série au travers de nos projets de mise en pratique. Vous trouverez les codes sources de ce sujet en les téléchargeant.

MERCI!

Cet article le moniteur série. Qu’est ce que c’est ? est apparu en premier sur PlaisirArduino.

Ma définition: while en anglais veut dire "tant que" en français . C'est une expression qui signifie "aussi longtemps que" . Le bloc while entre accolades {} s’exécutera tant que sa condition d'exécution est vraie. Soit "true" .

Elle est construite en deux parties.

• Une condition d’exécution () qui est le déclencheur de la boucle.
• Un bloc {} d'actions programmées à réaliser en boucle.

Se présente sous cette forme.(Exemple)

while ( Condition d’exécution ) { Bloc d’actions programmées ;}

Prenons l’exemple ci-dessus. Cela nous donne :

• Si la condition d'exécution () est vraie "true" , soit la variable de contrôle "resultat" inférieure à 50. L'action programmée sera exécutée.
• Le bloc d'actions programmées entre accolades {}: Réalise le calcul et affiche le résultat tant que la condition d'exécution est vraie "true" soit égale à "1".
  

Lorsque la variable "resultat"  appelée variable de contrôle aura une valeur supérieure à 49, la condition d’exécution deviendra fausse "false" . L'exécution en boucle se terminera et ne reprendra que lorsque la condition redeviendra vraie.

Une fois à l'intérieur de la boucle while, il faut pouvoir en sortir. Il faut donc que la ou les variables de contrôle utilisées dans la condition d'exécution soient manipulées ou changées via une action dans le bloc d'actions programmées. Sans cela while bouclera sans fin.

Il est toutefois possible d'agir de façon extérieure au bloc d'actions programmées en appelant dans la condition d’exécution "fonction" qui retourne une valeur vraie "true" ou fausse "false" après traitement.

Exemple: Ci contre nous attendons un retour de traitement de la fonction égale à zéro pour stopper l’exécution de la boucle while.

NOTE:

• La façon locale ou globale dont sera déclarée la variable de contrôle de la boucle déterminera le traitement de celle-ci et le déroulement de votre programme. Une variable de contrôle déclarée en local du programme principal loop() sera initialisée à sa valeur définie lors de chaque passage, ce qui entraînerait une exécution systématique du bloc while() en boucle, si sa condition est vraie. A l'inverse d'une variable déclarée en global.
  
• Il faut prendre garde à la manière dont on crée la condition d'exécution du bloc en boucle. L'utilisation d'une variable de type "float" utilisée avec un opérateur de comparaison " == " demanderait une valeur précise pouvant aller jusqu'au dixième près. Il y a risque de bloquer le programme principal dans une boucle sans fin. Dans ce cas là, il est recommandé d'utiliser les opérateurs de comparaison suivants (=> ou <=).
• Utile pour tester ou déboguer un programme; while(1); est parfois utilisé pour stopper un programme à un moment souhaité en le bloquant dans la boucle. Mais  pour effectuer un nouveau cycle programmé cela revient à "arracher la prise" par un téléversement ou un re-set de l'Arduino.

do{ } while( );

Ma définition: do en anglais veut dire faire en français. do est un bloc qui est systématiquement exécuté au moins une fois et répété en boucle tant que la condition d'exécution while, sera vraie "true" .while est ici en sortie de bloc.

Elle est construite en deux parties.

• Un bloc d'actions programmées entre accolades {} réalisé au moins une fois.
• Une condition d’exécution qui est cette fois, le déclencheur d'arrêt de la mise en boucle.

Se présente sous cette forme.(Exemple)

do{ bloc d'actions programmées ;} while(condition d’exécution) ;

Prenons l’exemple ci-dessus. Cela nous donne :

• Exécution systématique du bloc d'actions programmées do . Traitement du calcul et affichage de la valeur de "resultat" la variable de contrôle de while().
• Contrôle si la condition d'exécution de while est vraie "true" . Soit inférieure à 100. Réitération en boucle des actions programmées du bloc do tant que la condition d’exécution est vraie "true" . Une fois que la condition d'exécution sera fausse "false", la mise en boucle du bloc ne sera plus exécutée mais seulement exécutée une seule fois à chaque lecture du programme principal loop().

NOTE: Ne pas oublier le point virgule ";" à la suite de while() quand ce dernier succède au bloc do{}.

break;

Ma définition: break en anglais signifie casser ou pause en français. break est une instruction qui va dans notre cas stopper la mise en boucle du bloc dans lequel il est intégré et en sortir.

Se présente sous cette forme.(Exemple)

break ; //Arrête le bouclage du bloc dans lequel il est placé et en sort.

Toutes les instructions antérieures à break sont exécutées, le bloc ne sera exécuté qu'une seule fois,  break stoppe le bouclage et sort du bloc pour revenir au programme principal. Si la condition d'exécution est toujours vraie à la prochaine exécution de loop()  les instructions du bloc antérieur à break sont tout de même exécutées mais pas celles qui suivront ce dernier.

NOTE:

1. break peut être utilisé avec les blocs for, switch, while et do while.

Lorsque break se trouve dans une imbrication de boucle; il stoppera uniquement les instructions contenues dans le bloc (entre les accolades {}) dans lequel il est intégré.  Le programme poursuivra ensuite dans le bloc suivant.

continue;

Ma définition: continue en anglais veut dire évidement continuer en français. continue est une instruction qui va continuer la réitération d'un bouclage en ignorant les instructions qui suivent son emplacement

Se présente sous cette forme.(Exemple)

continue; //Ignore les instructions qui vont suivre et reboucler au début.

Dans l'exemple ci-dessus, nous intégrons une condition d’exécution pour activer l'instruction continue. Lorsque celle-ci sera vraie "true" soit "resultat" compris entre 50 et 70 , les instructions suivantes ne seront pas exécutées, c'est-à-dire le calcul numéro 2 et l'affichage de résultat . On rebouclera au début du bloc pour y refaire notre premier calcul.

NOTE:

• continue peut être utilisé dans les blocs for, while et do while.
• Pour l'exploiter il est préférable de conditionner son utilisation.
• Pour des essais et des contrôles, on peut utiliser continue sans conditionnement pour ignorer une portion finale de bloc que l'on ne souhaite pas exécuter en boucle.

FIN.

Vous connaissez à présent les bases des boucles while() et do{} while(); avec l'utilisation des instructions break; et continue;.

Découvrez  while / do while / break et continue en téléchargeant les sketchs référents de ce sujet. Merci.

Cet article while / do while + break; / continue;. est apparu en premier sur PlaisirArduino.