samedi 14 janvier 2017

Pourquoi écrire ses propres textes quand on peut plagier ceux des autres?

Hier soir, en fouinant un peu au hasard sur internet, je suis tombé sur Electronahal, un blog consacré à l'électronique qui m'a semblé, à première vue, assez intéressant.

Un article intitulé "Pinguino: fabrication et utilisation" a particulièrement éveillé mon intérêt. L'auteur, un dénommé Mouhcine Nahal, y raconte, photographies à l'appui, comment il a fabriqué deux modèles de Pinguino. Je dois dire qu'à mon humble avis, c'est un article plutôt réussi.  C'est d'ailleurs pour cette raison que je l'avais publié ici même, dans mon blog, le 30 août 2014...

Car voyez-vous, je suis l'auteur de cet article:  le texte, les photographies, les captures d'écran, le code, sont de moi.  C'est une reproduction fidèle, mot à mot, de mon article, à une exception près...mon nom a été remplacé par celui de Mouhcine Nahal.



Même constatation concernant l'article intitulé "Contrôle d'un moteur pas à pas avec un L293 (Arduino)", encore une fois attribué au même Mouhcine Nahal.  Il est plutôt pas mal, cet article. Mais c'est moi qui l'ai écrit.  Il avait été publié dans mon blog 2 ans avant d'être publié sur le blog de Monsieur Nahal.



On ne parle pas ici d'un blogueur qui se serait fortement inspiré d’un de mes articles, et aurait malencontreusement oublié d’indiquer ses sources (maladresse dont je suis parfois coupable, je dois l'admettre).  Il a repris l’intégralité de mon article, mot à mot, avec les mêmes photographies et les mêmes schémas, mais a remplacé mon nom par le sien!

On trouve de tout sur le blog Electronahal...sauf du contenu original.  D'après Google,  tout ce qu'écrit monsieur Nahal avait déjà été publié ailleurs...sous la signature de quelqu'un d'autre.


Comble de l'ironie:  dans le coin inférieur droit de la page, Mouhcine Nahal se déclare propriétaire des droits d'auteur de chaque article qu'il a plagié...



Il faut que je vous avoue quelque chose:  je suis un peu offusqué.  De tout ce que j’ai publié ici, Monsieur Nahal, seuls deux articles vous ont semblé dignes d’être plagiés?

Mise à jour (17 janvier 2017): Suite à mon signalement, Blogger a supprimé les deux pages qui reprenaient mes articles en version intégrale.  Chaque auteur doit lui-même signaler les violations qui le concernent, malheureusement. 


Mouhcine Nahal

Yves Pelletier   (TwitterFacebook)



vendredi 13 janvier 2017

Notifications par email, SMS ou Twitter avec ESP8266 et Carriots

Il y a quelques années, je vous avais présenté Carriots, un site web auquel vous pouvez envoyer des données issues de vos capteurs, afin de pouvoir les consulter à distance, et d'être averti par email, SMS ou Twitter lorsqu'une situation particulière se produit.

À l'époque, nous avions utilisé une carte Arduino et un Shield ethernet:  notre montage devait donc être relié par câble à un routeur.

Aujourd'hui, nous reprenons l'exercice mais, cette fois, nous programmerons un ESP8266 à l'aide de l'IDE Arduino pour qu'il envoie les données à Carriots par WiFi. (Ironiquement, en plus d'être beaucoup plus pratique, un module ESP8266 coûte beaucoup moins cher que la combinaison Arduino/Shield Ethernet que nous avions utilisé à l'époque.)

Notre dispositif

Nous reprendrons le même dispositif que dans l'article initial:  un capteur analogique (dans les faits:  un simple potentiomètre) est branché à la pin "ADC" de l'ESP8266.  Une LED est branchée à la pin GPIO04.

Aussi longtemps que la tension de la pin ADC (contrôlée par le potentiomètre) demeure en-dessous d'un certain seuil (que nous choisissons), la LED demeure éteinte.  Lorsque la tension de la pin ADC dépasse le seuil, la LED s'allume.  Chaque fois que la LED change d'état, nous envoyons un message à Carriots, qui se charge de nous envoyer un email (ou si vous préférez:  un tweet ou un sms) pour nous alerter.

Bien entendu, le potentiomètre peut être remplacé par n'importe quel autre capteur analogique (une photorésistance, par exemple).  Le notification peut aussi être déclenchée par une entrée numérique (au moyen d'un interrupteur, par exemple), il s'agira de modifier quelques lignes de code.  Si une seule entrée analogique ne vous suffit pas, vous pouvez vous référer à l'article "8 capteurs analogiques sur un même ESP8266".

À partir de là, les applications ne sont limitées que par votre imagination:  une boîte à lettre qui vous envoie un email pour vous aviser du passage du facteur, un système d'alarme qui vous avise par SMS qu'un mouvement a été détecté à l'intérieur de votre domicile, etc.

Le circuit

Puisque j'utilise un signal analogique. il me faut une version de l'ESP8266 qui comporte une entrée ADC, comme par exemple l'ESP-12.  Si vous ne disposez que du modeste ESP-01, qui ne comporte pas d'accès à l'entrée analogique, vous devrez modifier un peu le sketch pour que l'action soit accomplie lors d'un changement d'état d'une entrée numérique.


Le module est branché à un ordinateur par l'entremise d'un convertisseur USB-UART fonctionnant en 3,3 V, mais la forte consommation de l'ESP8266 nous oblige à l'alimenter avec une source externe plutôt qu'à la sortie 3,3 V du convertisseur USB-UART,

La pin GPIO0 doit être reliée au GND pour que le module puisse être programmé, mais il est préférable de la relier à 3,3 V pendant le fonctionnement du sketch.  Un reset est généralement nécessaire avant de téléverser le sketch (on fait un reset en branchant temporairement la pin RST à GND).

Une fois passée la phase de programmation et de débogage, le convertisseur USB-UART peut évidemment être retiré du circuit.

Un aspect agaçant de l'entrée analogique "ADC/TOUT" de l'ESP8266, c'est qu'elle accepte un signal analogique variant entre 0 et 1 V.   Je dois donc ajouter une résistance en série avec mon potentiomètre pour que la valeur maximale de l'entrée analogique soit de 1 V et non de 3,3 V. Pour un potentiomètre de 10 kΩ, une résistance de 23 kΩ fait l'affaire.  La valeur de résistance appropriée devra évidemment être calculée en fonction du capteur que vous utilisez:  assurez-vous que la tension transmise à la pin ADC/TOUT ne dépasse jamais 1 V.

La LED, associée à une résistance de protection, est branchée à la pin GPIO04.

Inscription à Carriots

À moins que ce ne soit déjà fait, le temps est venu d'ouvrir un compte gratuit chez Carriots,  Lorsque c'est fait, deux informations sont nécessaires pour qu'on puisse ensuite les intégrer à notre sketch: votre apikey, ainsi que le numéro d'identification de votre appareil.

Pour connaître votre apikey, vous cliquez sur "SETTINGS" dans le menu de gauche, puis sur "Apikeys".


Votre apikey est une interminable chaîne de caractères.  "Automatic apikey default" fait parfaitement l'affaire.  Un bouton bleu vous permet de la copier.


Vous devez également connaître le nom de votre appareil ("device").  Pour ce faire, accédez à la section "Devices"...


Vous pouvez créer un nouvel appareil, ou utiliser l'appareil par défaut qui a été automatiquement créé lors de votre inscription.  Ce qu'il vous faut, c'est le "id.Developer", qui est de la forme "nomDelappareil@votreNomDUtilisateur".



Le sketch

Je suppose ici que votre IDE Arduino a déjà été configuré pour permettre la programmation de l'ESP8266.  Si ce n'est pas le cas, je vous réfère à cette marche à suivre.

Avant de télécharger le sketch dans votre ESP8266, vous devez impérativement le modifier pour que 4 constantes comportent la bonne valeur:

ssid:  (acronyme de "service set identifier") le nom du réseau sans fil auquel l'ESP8266 se branchera.
password:  le mot de passe qui permettra à l'ESP8266 de se brancher au réseau sans fil
APIKEY:  l'apikey qui vous a été assignée par Carriots
DEVICE:  le nom de votre appareil sur le site de Carriots


Exécution du sketch

Pour vérifier que tout fonctionne normalement, il est préférable d'afficher le moniteur série (attention: vitesse de 115200 bauds).

Si le sketch ne s'exécute pas automatiquement, reliez la pin GPIO 0 à 3,3 V, puis faites un reset (branchez temporairement la pin reset à GND, puis branchez-la à nouveau à 3,3 V).

Si la connexion à votre réseau WiFi s'effectue correctement, vous devriez voir apparaître le message "Connexion au reseau en cours...", puis "Connecte au reseau:  (nom de votre réseau)".


En tournant le potentiomètre, vous devriez pouvoir allumer et éteindre la LED.  Chaque fois que la LED change d'état, vous devriez voir apparaître dans le moniteur série plusieurs lignes de données, qui commencent par "Envoi du Stream à Carriots", et qui se termine par ( "response": "OK").


Dans mon sketch, j'envoie une notification à Carriots à chaque changement d'état de la LED.  Bien entendu, je pourrais modifier mon sketch afin d'envoyer un message uniquement quand la LED s'allume, ou uniquement quand elle s'éteint.

Retournons maintenant sur le site de Carriots, et allons dans la section "Streams":
Vous devriez voir une ligne différente pour chaque message que votre ESP8266 a envoyé à Carriots:


Création d'un listener

La dernière étape, mais non la moindre, consiste à assigner un "listener" à notre appareil. C'est à dire un chien de garde qui s'occupera de nous envoyer une alerte (email, SMS ou tweet), chaque fois que notre ESP8266 enverra un message à Carriots.

Si votre intention est d'envoyer des tweets, vous devez d'abord autoriser Carriots à se connecter à votre compte Twitter.  C'est simple et rapide.



La façon la plus simple de créer un listener est d'utiliser le "Listener Wizard".


Première étape:  vous pouvez laisser les valeurs par défaut (le listener s'appliquera alors à tous vos appareils), ou sélectionner "Device" pour "Entity Type" et le nom de votre appareil pour"Id".


Deuxième étape:  vous choisissez si le listener vous enverra un email, un SMS ou un tweet.  Si vous choisissez "email", vous devez indiquer l'adresse email.  Si vous choisissez "SMS", on vous demande le numéro de téléphone.  Si vous choisissez "tweet", on vous demander le contenu du message à twitter.

Attention:  avec un compte gratuit, vous êtes limité à l'envoi de 5 SMS par jour (alors que vous pouvez envoyer 100 emails).


Dans une dernière étape, vous cliquez sur le bouton "Create Listener".  Vous devriez maintenant être avisé par la méthode choisie chaque fois que la LED change d'état.

Si ça ne fonctionne pas, vérifiez si vous trouvez des messages d'erreur dans la section "Alarms".

Yves Pelletier   (TwitterFacebook)

mardi 10 janvier 2017

Fabrication d'un pilote pour moteur pas à pas

Je vous présente aujourd'hui un petit compte rendu de la réalisation d'un pilote de moteur pas à pas: vous y branchez un moteur et une alimentation, et il s'agit d'appuyer sur quelques boutons pour faire tourner le moteur dans un sens ou dans l'autre, modifier sa vitesse de rotation, etc.

Cet appareil peut se révéler utile lorsque vous désirez vérifier si un moteur pas à pas fonctionne correctement, ou pour utiliser un moteur pas à pas de façon manuelle, sans que son fonctionnement soit automatisé par des capteurs.

À la base de notre circuit:  le traditionnel duo Arduino/L293D, dont j'avais déjà parlé dans ce blog il y a quelques années déjà.  Mais cette fois, puisque je veux un produit autonome, j'ai choisi d'utiliser un circuit intégré Atmega 328 plutôt qu'une carte Arduino complète.

Un petit cahier des charges:
  • Une seule alimentation permet d'alimenter à la fois le moteur pas à pas et les circuits intégrés Atmega et L293D.  Ces circuits intégrés nécessitent une tension de 5 V, alors que les moteurs requièrent souvent une plus grande tension:  un régulateur de tension est donc nécessaire.
  • Un bouton poussoir  marche/arrêt permet de mettre le moteur en marche, ou de l'arrêter. Une LED s'allume pour indiquer si ce bouton  est à l'état "marche".
  • Un bouton poussoir "marche inverse" permet d'inverser le sens de rotation du moteur.  Lui aussi est accompagné d'une LED indiquant si le mode "marche arrière" est en fonction.
  • Un potentiomètre permet de modifier la vitesse de rotation du moteur.
  • Un dernier bouton permet de faire tourner le moteur d'un seul pas à la fois.
Premier prototype, comportant une carte Arduino Uno

Même si le but final était de produire un circuit autonome comportant un microcontrôleur Atmega 328, j'ai tout de même commencé, dans une première phase de développement et de débogage, par un prototype sur platine d'essai branché à une carte Arduino Uno.

À cette étape, la carte Arduino fournit l'alimentation du circuit intégré, mais le moteur est alimenté par une source de tension externe.

Pour les 3 boutons, j'ai choisi d'utiliser les résistances pull-up interne de l'Arduino.  C'est pour cette raison que mes boutons ne comportent pas de résistance pull-up ou pull-down visible sur le circuit.

Le schéma ci-dessous montre où brancher chaque pin du L293D.


Et voici un schéma du circuit complet...



Sketch

Le sketch utilise la bibliothèque "stepper" qui est fournie avec l'IDE Arduino.  Puisque j'utilise les résistances pullup internes, digitalRead retourne "0" quand les boutons sont enfoncés, et "1" quand ils ne le sont pas.



Deuxième prototype, comportant un Atmega 328 sur breadboard

Rien ne vous empêche de vous arrêter à cette étape du circuit et, par exemple, en faire un shield pour votre carte Arduino.  Mais comme je le mentionnais au début de l'article, je préférais produire un circuit pouvant fonctionner de façon parfaitement autonome.

L'étape suivante consistait donc à graver le bootloader sur un Atmega 328 vierge, puis à y graver mon sketch. Pour une marche à suivre détaillée, je vous invite à consulter mon vieil article intitulé "Fabriquer son propre Arduino sur une breadboard".

Il restait ensuite à migrer les connexions de la carte Uno vers l'Atmega, d'ajouter un quartz de 16 MHz, ainsi qu'un régulateur de tension LM7805.

Le schéma ci-dessous indique où est branchée chaque pin de l'Atmega 328.


Du côté, du L293, ça demeure la même chose que dans le circuit précédent:


Les deux circuits intégrés demandent des tension d'alimentation de 5 V, alors que notre moteur pas à pas en exigera peut-être plus, d'où l'utilisation d'un régulateur linéaire  LM7805 qui abaissera la tension de départ (7 V ou plus) en une tension de 5 V.  J'en ai profité pour ajouter une LED qui indique que la carte est alimentée.

Et voici le schéma complet du circuit...




Le produit fini 

Voici le circuit proprement soudé sur une plaque pastillée.  Tout fonctionne tel que désiré.



Yves Pelletier   (TwitterFacebook)

vendredi 6 janvier 2017

Scratch sur Rasbperry Pi (3): Modifions la luminosité d'une LED

Dans ce troisième tutoriel concernant l'électronique avec le logiciel Scratch sur Rasbperry Pi, nous allons modifier l'intensité lumineuse d'une LED au moyen des touches du clavier.

Si ce n'est pas déjà fait, je vous conseille la lecture premier tutoriel de cette série: Scratch sur Raspberry Pi (1): Faisons clignoter une LED. Dans cette activité, la LED ne pouvais avoir que 2 états: complètement éteinte, ou complètement allumée. Dans l'activité d'aujourd'hui, elle pourra prendre plusieurs d'états différents, comme par exemple "allumée à 20% de son intensité maximale" ou "allumée à 60% de son intensité maximale".

Construction du circuit

Nous allons utiliser exactement le même circuit que dans le premier tutoriel: une LED (peu importe la couleur) est branchée en série avec une résistance (la résistance doit avoir une valeur se situant quelque part entre 100 Ω et 300 Ω).

La broche la plus longue de la LED est reliée à la pin 14 du Raspberry Pi (il s'agit de la quatrième pin de la rangée du haut,  tel qu'illustré), alors qu'à l'autre extrémité du circuit, la résistance est reliée à une des pins GND (la troisième pin de la rangée du haut, tel qu'illustré).

La LED sera allumée quand la pin 14 sera à 3,3 V, et éteinte quand elle sera à 0 V. Comment varier son intensité lumineuse?  En la faisant clignoter très rapidement.  Cette façon de contrôler la luminosité de la LED s'appelle "modulation par largeur d'impulsion", ou PWM (pour "pulse width modulation").

Construction du programme dans Scratch

Démarrons le logiciel Scratch (il se trouve dans le menu "Programmation").

Nous allons d'abord nous occuper de ce qui se produira au début du programme, lorsqu'on clique sur le bouton en forme de drapeau.

Dans la catégorie "contrôle", nous prenons un bloc "quand drapeau pressé", ainsi qu'un bloc "envoyer à tous".

Comme message dans le bloc envoyer à tous, nous écrivons:  "gpioserveron ".


Ce message démarrera le serveur GPIO, qui permet à nos programmes Scratch de contrôler les pins GPIO du Raspberry Pi.  Une autre méthode aurait consisté à démarrer nous-mêmes le serveur GPIO en choisissant "Start GPIO Server" dans le menu "Éditer", mais grâce à ce bloc, ce sera fait automatiquement.

Ajoutons un autre bloc "envoyer à tous".  Celui-ci enverra le message "config14outputpwm".  Ce message signifie que la pin 14 à laquelle nous avons branché la LED sera une sortie qu'il sera possible de faire clignoter très rapidement.


L'étape suivante consiste à créer une variable qui contiendra un nombre correspondant à la luminosité de la LED.  Dans la catégorie "Variables", cliquez sur le bouton "Nouvelle variable".


Nous donnons à cette variable le nom "luminosité".


Quand la variable "luminosité" contiendra la valeur "0", la LED sera éteinte.  Quand sa valeur sera "30", la LED sera allumée à 30% de son intensité maximale, etc.  Au moyen d'un bloc "à luminosité attribuer", nous allons régler sa valeur initiale à 50, ce qui correspond à 50% de la valeur maximale.


La variable "luminosité" contient le nombre 50.  Nous allons maintenant envoyer un message pour ordonner à la LED se s'allumer avec cette luminosité.  Nous ajoutons donc un nouveau bloc "envoyer à tous":


Nous nous rendons ensuite dans la catégorie "Opérateurs" pour prendre un bloc "joindre salut monde" que nous faisons glisser à l'intérieur du bloc "envoyer à tous":


Retour à la catégorie "variables" afin de faire glisser le bloc "luminosité" au-dessus du deuxième élément du bloc "joindre":


Et nous remplaçons le mot "salut" par "gpio14pwm":


Puisque la variable "luminosité" contient le nombre 50, le message envoyé sera "gpio14pwm50", ce qui obligera la pin 14 à clignoter rapidement, en étant allumée 50% du temps.

La suite de notre programme consiste à augmenter la luminosité de la LED lorsque l'utilisateur appuie sur la touche "flèche vers le haut du clavier".

Dans la catégorie "Contrôle", nous choisissons le bloc "quand espace est pressé", et nous remplaçons "espace" par "flèche haut".


Lorsque l'utilisateur pressera la flèche vers le haut, nous voulons que la variable "luminosité" augmente de 10.  Dans la catégorie "Variables", nous utilisons un bloc "à luminosité ajouter 1" et nous remplaçons 1 par 10:


...et nous ordonnons à la LED de briller selon cette nouvelle valeur:


(une façon simple consiste à faire un clic droit sur le bloc identique situé plus haut, et choisir "dupliquer").

Quand c'est la flèche vers le bas qui est pressée, nous voulons soustraire 10 de la variable "luminosité", ce qui revient à lui additionner "-10":


Et notre programme est complet!

Mise à l'essai du programme

Vous cliquez sur le bouton en forme de drapeau pour démarrer le programme.  La LED devrait devenir plus lumineuse quand vous appuyez sur la touche "flèche vers le haut" du clavier, et moins lumineuse quand vous appuyez sur la touche "flèche vers le bas".

Observation du signal PWM

Voici ce qu'on obtient lorsqu'on branche un oscilloscope à la pin 14 du Raspberry Pi...

... pendant que la variable "luminosité" est à 0 (la tension est toujours 0 V):


Pendant que la variable "luminosité" vaut 30 (la sortie est à 3 V 30% du temps, et à 0 pendant 70% du temps):


Pendant que luminosité est à 50 (sortie à 3 V 50% du temps):


Pendant que "luminosité" est à 80:



Et, finalement, quand luminosité est à 100:



Yves Pelletier   (TwitterFacebook)

lundi 2 janvier 2017

Utiliser un afficheur LCD 2 X 16 avec une carte Arduino

Il est souvent utile d'afficher des informations numériques ou textuelles produites par une carte Arduino (une mesure effectuée par un capteur, par exemple).   Aussi longtemps que l'Arduino est branché à un ordinateur, on peut utiliser le moniteur série intégré à l'IDE pour afficher ces informations.  Mais si vous désirez mettre au point un dispositif autonome qui pourra fonctionner loin de l'ordinateur, un afficheur à cristaux liquides (ou LCD, pour "liquid crystal display") s'avère une solution pratique, et relativement simple.

Nous parlons aujourd'hui des afficheurs compatibles avec le pilote Hitachi HD44780, qui permettent d'afficher des nombres et des lettres de l'alphabet (2 lignes comportant 16 caractères chacune).  Si vous avez besoin d'afficher des illustrations, un afficheur LCD Nokia 5110 correspondra peut-être mieux à vos besoins.

Connexions

Les afficheurs compatibles avec le pilote HD44780 comportent 16 connecteurs.  Les connexions que je vous propose ici vous permettront d'utiliser sans modification les exemples de sketches fournis avec la bibliothèque LiquidCrystal.  Pour certains projets, il est possible que vous soyez obligé de modifier certaines de ces connexions si d'autres périphériques occupent déjà les mêmes entrées/sorties de l'Arduino.

Les pins 1 et 2 servent à alimenter l'afficheur:
  • Pin 1 de l'afficheur --- 5 V de la carte Arduino
  • Pin 2 de l'afficheur --- GND de la carte Arduino
La pin 3 sert à régler le contraste de l'afficheur:  on la relie à un potentiomètre de 10 kΩ qui permet de faire d'ajuster sa tension à une valeur située entre 0 et 5 V.
  • Pin 3 de l'afficheur --- Curseur d'un potentiomètre dont les deux autres broches sont reliées respectivement à GND et à 5 V.
  • Pin 4 "RS" de l'afficheur --- Pin 12 de l'Arduino
  • Pin 5 "R/W" de l'afficheur --- GND de l'Arduino
  • Pin 6 "Enable" de l'afficheur --- Pin 11 de l'Arduino
Les pins 7, 8, 9 et 10 de l'afficheur ne sont pas branchées, car nous utiliserons l'afficheur en mode 4 bits plutôt qu'en mode 8 bits (ce qui permet d'économiser les entrées/sorties de l'Arduino).
  • Pin 11 "D4" de l'afficheur --- Pin 5 de l'Arduino
  • Pin 12 "D5" de l'afficheur --- Pin 4 de l'Arduino
  • Pin 13 "D6" de l'afficheur --- Pin 3 de l'Arduino
  • Pin 14 "D7" de l'afficheur --- Pin 2 de l'Arduino
Les pins 15 et 16 servent à alimenter le rétroéclairage.  Sur certains modèles d'afficheur, le rétroéclairage n'est pas indispensable (sauf pour lire l'affichage dans l'obscurité), alors que pour d'autres modèles l'affichage est illisible si le rétroéclairage n'est pas activé.
  • Pin 15 de l'afficheur --- Résistance d'environ 100 Ω*  --- 5 V de l'Arduino
  • Pin 16 de l'afficheur --- GND de l'Arduino
(* j'ai un afficheur dont le rétroéclairage ne s'allume qu'à la condition que je n'ajoute aucune résistance)

La bibliothèque LiquidCrystal

Pour présenter les informations sur l'afficheur, nous utiliserons la bibliothèque "LiquidCrystal", qui a été spécialement conçue à cette fin.  Nul besoin de l'installer, puisqu'elle est fournie avec l'IDE.



Pour vérifier rapidement que votre afficheur est bel et bien fonctionnel, téléchargez l'exemple "HelloWord" dans votre Arduino.  Vous devriez voir le message "hello, world!" apparaître sur la première ligne de l'afficheur, alors que sur la deuxième ligne un compteur s'incrémente à chaque seconde.


Si rien ne s'affiche, pas de panique!  Tournez le bouton du potentiomètre qui contrôle le contraste. Sinon, vérifiez à nouveau toutes les connexions.  

Pour afficher un texte, on utilise la commande "print".  Le texte débute toujours à la position du curseur.   Lorsque vous écrivez quelque chose, le curseur se déplace automatiquement à la position qui suit immédiatement le texte affiché.

La position du curseur se règle au moyen de la commande "setCursor(colonne, ligne)".  Il est important de noter que la première ligne en haut porte le numéro 0, et la première colonne à gauche porte le numéro 0.  L'instruction "lcd.setCursor(0,0)" positionnera donc le curseur en haut à gauche.
Si vous désirez que l'utilisateur entre du texte qui apparaîtra à l'afficheur, il peut être utile de montrer un symbole clignotant qui indique la position du curseur, en utilisant la commande "blink".  Pour des exemples de situation où on affiche du texte tapé par l'utilisateur, vous pouvez vous référer à mon article Arduino, clavier numérique et afficheur LCD.

Je vous propose ci-dessous un sketch de mon crû, qui a l'avantage d'être commenté en français.  

Dans un premier temps, un texte fixe apparaît, centré sur l'écran.  Je fais ensuite défiler un texte vers la gauche et vers la droite, j'affiche un texte caractère par caractère, je fais clignoter un texte, puis je fais apparaître un curseur clignotant et je change sa position (voir l'afficheur en action sur la vidéo ci-dessous).





Vous serez peut-être intéressé par cet article qui montre comment produire une progress bar sur un LCD.

Pour quelques exemples d'utilisation d'un afficheur LCD à l'intérieur d'un projet impliquant l'Arduino, vous pouvez consulter les articles suivants:  Arduino, clavier numérique et afficheur LCDUne horloge pour votre Arduino et Mesurer une température avec un Arduino.

Vous pouvez également apprendre à utiliser un afficheur LCD avec un Raspberry Pi, une carte MSP430 Launchpad, ou une carte Pinguino ou une carte STM32 Nucleo.

Yves Pelletier   (TwitterFacebook)

Related Posts Plugin for WordPress, Blogger...