vendredi 28 décembre 2018

Kit: détecteur de métaux EQKIT MDS-60

Sur des sites comme eBay ou Aliexpress, vous pouvez vous procurer, pour environ 1 euro, un kit permettant de construire un détecteur de métaux pas très performant, mais néanmoins fonctionnel.

Le kit est constitué d'un circuit imprimé qui comporte sur chaque face un fil conducteur en forme de spirale, en plus de 16 composants à souder soi-même: 3 résistances, 5 condensateurs, 3 transistors, une LED, un potentiomètre, un buzzer piézo, un bornier à vis et un interrupteur.



Assemblage

Le kit est livré sans manuel d'instructions, mais les informations écrites directement sur le circuit imprimé sont suffisantes pour permettre à l'utilisateur de placer chaque composant au bon endroit.

La valeur de chaque résistance est indiquée sur le circuit imprimé: R1 est la résistance de 200 kΩ (bandes rouge-noir-jaune), R2 est la résistance de 2 kΩ (bandes rouge-noir-rouge) et R3 est la résistance de 470 Ω (bandes jaune-violet-brun).


C1 et C4 sont des condensateurs céramique de 100 nF (104), alors que C2 et C3 sont des condensateurs céramique de 2,2 nF (222).



Q1 est un transistor S9018 (NPN), alors que Q2 et Q3 sont des transistors S9012 (PNP). Puisque le profil du boîtier TO-92 est clairement dessiné sur le circuit imprimé, il faudrait être particulièrement négligeant pour les souder à l'envers.


En plaçant la LED et le condensateur électrolytique de 100 µF, il faut faire attention à la polarité: le trou entouré d'un carré est la borne positive, et on y insère donc la broche la plus longue.


VR1 est le potentiomètre qui permet de régler la sensibilité du détecteur.



On fait attention à la polarité du buzzer piézo: la borne positive est indiquée sur l'étiquette (c'est aussi la broche la plus longue).


J'ai finalement soudé l'interrupteur marche-arrêt et le bornier à vis.



Mon évaluation de la phase d'assemblage: il s'agit d'un kit facile, qui convient parfaitement aux néophytes (en fait, la plupart des composants ont été soudés par mon fils Zachary, qui n'avait jamais eu l'occasion de souder auparavant).

Test et utilisation du détecteur de métaux

Le détecteur de métaux doit être alimenté par une source de tension continue de 3 à 5 V (qui n'est pas incluse). Au moyen d'un petit tournevis, vous devrez probablement ajuster le potentiomètre (VR1) pour ajuster le circuit (de façon à ce qu'il ne réagisse qu'à proximité d'un objet métallique).

Les premiers tests, réalisés au moyen d'une pièce de monnaie, se sont révélés positifs, mais il faut placer le détecteur vraiment très proche de la pièce (la portée officielle de 6 cm semble quelque peu optimiste, mais peut-être qu'un meilleur réglage du potentiomètre permettrait l'obtention de meilleurs résultats).


Mon évaluation du détecteur de métaux: je le vois plus comme un jouet éducatif que comme un outil vraiment utile. Ne comptez pas trop sur ce dispositif pour trouver des bijoux enfouis sous le sable d'une plage...

Yves Pelletier   (TwitterFacebook)
(avec la précieuse collaboration de Zachary Pelletier)

mardi 25 décembre 2018

Boîte cadeau musicale et lumineuse (Arduino)

À l'occasion de Noël, j'ai fabriqué une boîte cadeau qui sort un peu de l'ordinaire: elle comporte une figurine de Père Noël qui danse (animée par un servomoteur), un haut-parleur qui diffuse une mélodie de Noël, une dizaine de LEDs clignotantes de diverses couleurs, et un écran LCD qui affiche des souhaits de circonstance.

Voyez vous-même:


Toute cette électronique pour ... une boîte?

Si on part du principe qu'une fois ouverte, la boîte sera immédiatement mise au recyclage, il semble peu raisonnable d'y placer tout cet appareillage électronique. Par contre, rien ne vous empêche de repartir avec la boîte après avoir offert le cadeau qu'elle contient.  Autre possibilité: il s'agit d'une façon originale d'offrir en cadeau un kit Arduino...

Le circuit



La base du dispositif est un Arduino Uno. Pour que la boîte puisse facilement être transportée, il est alimenté par une pile de 9 V. Un interrupteur marche-arrêt permet de le mettre en marche au moment approprié et, peut-être plus important encore, l'arrêter quand vous en avez ras le bol...  Puisque ma boîte était de grande dimension, je n'ai pas jugé utile de miniaturiser mon circuit avec un Arduino Nano.


La figurine de Père Noël qui danse est attachée à un petit servomoteur qui effectue un mouvement de va-et-vient de 90° d'amplitude.  Il est contrôlé par la broche 9 de l'Arduino.


Le haut-parleur a été branché à la broche 8 de  l'Arduino par l'entremise d'un transistor, tel que recommandé dans un précédent billet.  Des petits trous on été pratiqués dans la boîte, devant le haut-parleur, pour faciliter la diffusion du son.  Personnellement, je préfère les hauts-parleurs, mais vous pouvez aussi utiliser un piézo.



L'afficheur LCD tient lieu d'étiquette et pourrait être utilisé pour écrire à qui est destiné le cadeau, de la part de qui, etc.  L'effet est plus intéressant si le message affiché change périodiquement.  Pour plus d'informations sur l'utilisation d'un afficheur LCD 2 X 16, consultez ce billet.



Les broches A0 à A5 de l'Arduino sont utilisées comme sorties numériques pour contrôler les LEDs.  Les LEDs rouges et les LEDs vertes ont été placées en paires, mais pas les LEDs bleues, puisqu'elles nécessitent une plus grande tension.



Bien entendu, chaque élément de la boîte est facultatif: vous pouvez fabriquer une boîte cadeau très spectaculaire sans afficheur LCD, par exemple.


Le sketch

Puisque chaque élément du circuit avait déjà été utilisé dans d'autres projets, la seule difficulté, lors de la programmation, a été de faire en sorte que tout s'effectue simultanément sans interférer avec les autres parties du circuit.

Il aurait été facile de jouer la mélodie au complet, de faire ensuite bouger le Père Noël une fois la musique terminée, et finalement faire clignoter quelques LEDs, mais il était important que le Père Noël bouge pendant que la musique joue et que les LEDs clignotent, d'où l'utilisation assez intensive de la fonction millis() pour vérifier si c'est le moment de jouer une nouvelle note, de changer l'état d'une LED, ou de bouger le Père Noël, avec interdiction totale d'utiliser la fonction delay()!!!

À noter que chaque groupe de LED a sa propre fréquence de clignotement, ce qui donne un effet pseudo aléatoire qui me plaît bien.


Yves Pelletier   (TwitterFacebook)

mercredi 19 décembre 2018

Arduino chante Noël


Je vous propose aujourd'hui quelques mélodies de Noël qui pourraient s'avérer utile à l'intérieur d'un projet Arduino (carte de souhait musicale ou autre).

Les 5 mélodies sont:
  • Vive le vent (Jingle Bells)
  • We Wish You a Merry Christmas
  • Le petit Renne au nez rouge
  • Petit papa Noël
  • Au royaume du bonhomme hiver

Le circuit

Il s'agit de brancher un haut-parleur ou un piézo à la broche 8 de l'Arduino­.

À cause de la très faible impédance d'un haut-parleur, il est fortement déconseillé de le brancher directement à l'Arduino: utilisez plutôt un circuit comportant un transistor, tel qu'illustré ci-dessous (plus d'informations ici).


Cette précaution n'est pas utile si vous utilisez un piézo, puisque son impédance est très élevée.


Le sketch

Le sketch utilise la fonction tone() pour produire des notes.  Chaque mélodie a été définie à l'intérieur de sa propre fonction, pour faciliter le copier/coller de la mélodie désirée dans votre propre sketch.





Yves Pelletier   (TwitterFacebook)

samedi 15 décembre 2018

Menus de navigation sur écran Nokia 5110 (Arduino)

Dans ce quatrième billet consécutif mettant en vedette un petit écran LCD de type Nokia 5110 contrôlé par un Arduino Uno, je vous présente un sketch qui permet de naviguer dans des menus au moyen de 4 boutons poussoirs.

Le menu principal comporte un certain nombre de sous-menus. Chaque sous-menu donne accès à une deuxième page comportant une liste d'items pouvant être sélectionnés par l'utilisateur.

Le bouton "flèche vers le bas" permet de sélectionner l'item se situant une ligne plus bas dans la liste. Le bouton "flèche vers le haut" permet de sélectionner l'item se situant une ligne plus haut dans la liste. Le bouton "flèche vers la droite" permet d'exécuter l'item de la liste qui est sélectionné. Le bouton "flèche vers la gauche" permet de revenir à la page précédente.

Le nombre de sous-menus dans le menu principal ainsi que le nombre d'items dans chaque sous-menu peu facilement être modifié à l'intérieur du sketch.

 Je vous présente immédiatement une courte vidéo montrant le résultat:

   

Le circuit  

L'écran Nokia est branché à l'Arduino de la même façon que dans mes 3 billets précédents: un circuit intégré 4050 a été utilisé afin d'abaisser à 3,3 V les tension de sortie de l'Arduino Uno (voir ce précédent billet pour plus de détails concernant les branchements du 4050).
  • La broche SCE de l'afficheur reçoit le signal provenant de la broche 4 de l'Arduino
  • La broche RST de l'afficheur reçoit le signal provenant de la broche 3 de l'Arduino
  • La broche D/C de l'afficheur reçoit le signal de la broche 5 de l'Arduino
  • La broche DN/MOSI de l'afficheur reçoit le signal de la broche 11 de l'Arduino
  • La broche SCLK de l'afficheur reçoit le signal de la broche 13 de l'Arduino
De plus, 4 boutons sont associés à une résistance de tirage de 10 kΩ et branchés à l'Arduino de la façon suivante:
  • bouton "flèche vers le haut": broche 6 de l'Arduino
  • bouton "flèche vers le bas": broche 7 de l'Arduino
  • bouton "flèche vers la gauche": broche 8 de l'Arduino
  • bouton "flèche vers la droite": broche 9 de l'Arduino


Le sketch

Pour utiliser ce sketch, il faut d'abord avoir installé les bibliothèques Adafruit-PCD8544-Nokia-5110-LCD-library et Adafruit-GFX-Library dans votre IDE Arduino.

La fonction loop() consiste essentiellement à surveiller l'état des boutons et, lorsque l'un d'eux a été enfoncé, modifier l'état des variables appropriées (un délai de 50 millisecondes a été prévu pour éviter les rebonds).

La fonction miseAJour() est responsable de dessiner le contenu de l'écran en fonction de l'état des variables ayant été modifiées au moyen des boutons. Par exemple, la variable NumeroMenu prend la valeur "0" lorsqu'il faut afficher le menu principal, mais devient "1" lorsque le sous-menu numéro 1 a été sélectionné. La variable NumeroItem contient le numéro de l'élément de la liste qui est sélectionné (donc écriture blanche sur fond noir).  Puisque l'écran ne peut montrer que 4 éléments de la liste à la fois, mais que la liste peut contenir plus de 4 éléments. la variable numeroTeteDeListe contient le numéro du premier élément à afficher dans le haut de l'écran.

Bien entendu, le texte de chaque liste peut être modifié à volonté de façon à produire un programme qui répond à vos besoins (dans son état actuel, chaque titre doit comporter un maximum de 14 caractères, ce qui est sensiblement la taille maximale pouvant être affichée sur une ligne de l'écran).



Yves Pelletier   (TwitterFacebook)

lundi 10 décembre 2018

Graphique cartésien sur écran Nokia 5110 (Arduino)

Pour ce troisième billet consécutif concernant l'utilisation d'un écran Nokia 5110 contrôlé par une carte Arduino, je me suis amusé à présenter sous la forme d'un graphique cartésien la tension mesurée à l'entrée analogique A0 de l'Arduino (graphique tension vs temps).


Puisque l'écran a 84 pixels de largeur et que j'ai choisi de séparer chaque mesure par une distance horizontale de 4 pixels, l'écran présente en tout temps les 21 mesures les plus récentes.

Connexions

L'écran Nokia 5110 est branché à l'Arduino de la même façon que dans mon précédent article sur le sujet: encore une fois, j'ai utilisé un circuit intégré 4050 afin que le niveau logique de 5 V des signaux issus de l'Arduino soient abaissés à 3,3 V aux entrées de l'écran.

  • La broche SCE de l'afficheur reçoit le signal provenant de la broche 4 de l'Arduino
  • La broche RST de l'afficheur reçoit le signal provenant de la broche 3 de l'Arduino
  • La broche D/C de l'afficheur reçoit le signal de la broche 5 de l'Arduino
  • La broche DN/MOSI de l'afficheur reçoit le signal de la broche 11 de l'Arduino
  • La broche SCLK de l'afficheur reçoit le signal de la broche 13 de l'Arduino

Pour mes tests, j'ai fait varier la tension de l'entrée A0 avec un potentiomètre, qui pourra bien entendu être remplacé par un capteur plus utile.



Le sketch

Le sketch ci-dessous fonctionnera à la condition d'avoir préalablement installé les bibliothèques Adafruit-PCD8544-Nokia-5110-LCD-library et Adafruit-GFX-Library dans votre IDE Arduino.

L'algorithme est légèrement différent pour les 21 premières mesures que pour celles qui suivent. S'il y a encore de l'espace libre sur l'écran, on se contente de tracer le petit bout de graphique qui s'ajoute au dessin déjà affiché.  Par contre, si l'écran est déjà plein, nous devons effectuer une translation du graphique déjà tracé (déplacement de 4 pixels vers la gauche) afin de libérer de l'espace pour notre nouvelle mesure, à l'extrême droite du graphique. Cela impose de redessiner tout le contenu de l'écran.

Le rythme auquel l'Arduino prend ses mesures (et donc la vitesse à laquelle le graphique évolue à l'écran) peut être modifié grâce à la variable "intervalle", qui est le temps en millisecondes entre deux mesures consécutives.

J'ai aussi tracé six traits horizontaux qui représentent les graduations de 0 à 5 volts. Ils peuvent être omis si vous jugez que l'écran est trop surchargé.



Vidéo

Pour terminer, voici une courte vidéo montrant le tracé du plan cartésien en temps réel.



Yves Pelletier   (TwitterFacebook)


vendredi 7 décembre 2018

Présentation d'une mesure analogique sur écran Nokia 5110 (Arduino)

Après avoir exploré les différentes possibilités offertes par les bibliothèques PCD8544 et GFX d'Adafruit pour piloter un écran Nokia 5110 avec un Arduino, nous pouvons maintenant mettre en pratique nos connaissances afin de produire une application spécifique: l'affichage de la tension reçue à une des entrées analogiques de l'Arduino sous la forme d'un nombre ainsi que d'une jauge linéaire.



Montage

L'écran Nokia est branché à l'Arduino de la même façon que dans mon article précédent (je vous invite à vous y référer pour plus de détails).  Un circuit intégré 4050 est utilisé pour abaisser à 3,3 V les signaux logiques produits par les sorties de l'Arduino, afin de respecter la fiche technique du contrôleur PCD8544.

En résumé:

  • La broche SCE de l'afficheur reçoit le signal provenant de la broche 4 de l'Arduino
  • La broche RST de l'afficheur reçoit le signal provenant de la broche 3 de l'Arduino
  • La broche D/C de l'afficheur reçoit le signal de la broche 5 de l'Arduino
  • La broche DN/MOSI de l'afficheur reçoit le signal de la broche 11 de l'Arduino
  • La broche SCLK de l'afficheur reçoit le signal de la broche 13 de l'Arduino
Pour effectuer mes tests, j'ai utilisé un potentiomètre afin de faire varier la tension appliquée à l'entrée A0 de l'Arduino. Bien entendu, vous pouvez remplacer le potentiomètre par tout autre capteur analogique (photorésistance, thermistance, etc.).  De plus, à la condition de modifier le sketch, vous pouvez remplacer le capteur analogique par un capteur numérique.



Sketch

Le sketch est plutôt simple.  À intervalles réguliers, la valeur de l'entrée analogique A0 est mesurée grâce à la fonction analogRead().

Cette valeur, qui peut varier entre 0 et 1023, est ensuite convertie en volts au moyen de la fonction map().  Vous pourrez facilement modifier le sketch si vous désirez afficher la valeur brute entre 0 et 1023, ou si vous voulez la transformer afin d'afficher autre chose qu'une tension en volts.

De plus, une jauge linéaire montre le résultat de façon graphique (il s'agit d'un mince rectangle dont la longueur horizontale est proportionnelle à la valeur mesurée).

Pour que le sketch fonctionne, il faut  avoir préalablement installé les bibliothèques Adafruit-PCD8544-Nokia-5110-LCD-library et Adafruit-GFX-Library dans votre IDE Arduino.



Vidéo

Pour terminer, voici une vidéo du montage en action.



Yves Pelletier
   (TwitterFacebook)


dimanche 2 décembre 2018

Afficheur LCD Nokia 5110 et Arduino

Dans cet article, je vais tenter de vous expliquer de la façon la plus claire et complète possible comment piloter un petit écran à cristaux liquide de type "Nokia 5110" au moyen d'un Arduino Uno: vous saurez comment procéder pour brancher l'afficheur et pour programmer l'Arduino afin que l'écran affiche du texte et des images.


"Nokia 5110" est, en fait, le nom d'un modèle de téléphone portable commercialisé entre 1998 et 2001 qui utilisait ce type d'écran. Il s'agit d'un afficheur LCD monochrome associé à un contrôleur Philips PCD8544, avec une résolution de 84 X 48 pixels (sa taille réelle est de 3,5 cm par 2,5 cm environ).  Vous pouvez y afficher du texte et des dessins mais, bien entendu, ce ne sera pas de la haute résolution...

Pour faciliter les branchements avec un microcontrôleur, il existe  sur le marché deux types de breakout: le modèle rouge commercialisé par Sparkfun, et le modèle bleu commercialisé par Adafruit. Des clones de ces deux modèles sont proposés pour environ la moitié du prix par les revendeurs asiatiques. J'ai moi-même utilisé le modèle de type Sparkfun, mais vous pouvez sans problème utiliser les informations que je vous présente ici avec le modèle de type Adafruit.  Vous devrez souder vous-même une barrette de 8 connecteurs (mâles ou femelles, selon votre préférence).



Téléchargement et installation des bibliothèques

Je vous recommande l'utilisation de la bibliothèque Adafruit-PCD8544-Nokia-5110-LCD-library qui, comme son nom l'indique, a été mise au point par la compagnie Adafruit. Vous devez également installer la bibliothèque Adafruit-GFX-Library, qui comporte les routines permettant de dessiner à l'écran ("GXF" dans le sens de "graphics").

Au cas où ça vous intéresserait: il existe aussi une bibliothèque conçue par Carlos Rodrigues qui offre beaucoup moins de possibilités,  mais est moins gourmande en ressources. Ça pourrait s'avérer intéressant si vous désirez uniquement afficher du texte (caractères de 5 X 8 pixels). Je n'ai pas fait l'essai de cette bibliothèque allégée, puisque la bibliothèque proposée par Adafruit a parfaitement répondu à mes besoins.

Connexions

Mauvaise nouvelle: le pilote PCD8544 fonctionne à un niveau logique de 3,3 V.  Si vous utilisez un Arduino Uno (ou un autre modèle d'Arduino fonctionnant à un niveau logique de 5 V), il est recommandé abaisser la tension avant de l'acheminer à l'afficheur.

Bien sûr, vous trouverez sur le web tout un tas de tutoriels proposant de brancher directement les sorties 5 V de l'Arduino aux entrées 3,3 V de l'afficheur sous prétexte que les entrées de l'afficheur tolèrent les tensions de 5 V; mais ce n'est pas ce que dit le site de Sparkfun, ni celui d'Adafruit. Si vous branchez directement l'afficheur aux sorties de l'Arduino sans abaisser le niveau logique, il fonctionnera sans doute très bien, mais sa durée de vie utile pourrait être sérieusement diminuée.

J'ai donc utilisé un circuit intégré 4050, qui est spécialement conçu pour ce genre d'applications.

Voici donc le circuit complet:


Attention: le circuit illustré utilise la version Sparkfun de l'afficheur. Si vous utilisez plutôt la version Adafruit, les broches de l'afficheur ne sont pas dans le même ordre. Référez-vous plutôt aux noms des broches indiqués ci-dessous.

Alimentation:
  • La broche VCC de l'afficheur et la broche 1 du 4050 sont branchés à la sortie 3.3 V de l'Arduino.
  • La broche GND de l'afficheur et la broche 8 du 4050 sont branchés à la broche GND de l'Arduino.
Sorties de l'Arduino:
  • La broche 3 de l'Arduino est branchée à la broche 3 du 4050
  • La broche 4 de l'Arduino est branchée à la broche 5 du 4050
  • La broche 5 de l'Arduino est branchée à la broche 7 du 4050
  • La broche 11 de l'Arduino est branchée à la broche 14 du 4050
  • La broche 13 de l'Arduino est branchée à la broche 11 du 4050
(Notez que vous pouvez choisir d'autres sorties de l'Arduino si vous préférez, en faisant les changements appropriés dans le sketch. Toutefois, l'utilisation des broches 11 et 13 de l'Arduino permet une plus grande vitesse de communication avec l'afficheur).

Entrées de l'afficheur:
  • La broche SCE ou CS de l'afficheur est branchée à la broche 4 du 4050
  • La broche RST de l'afficheur est branchée à la broche 2 du 4050
  • La broche D/C de l'afficheur est branchée à la broche 6 du 4050
  • La broche DN (MOSI) ou DIN de l'afficheur est branchée à la broche 15 du 4050
  • La broche SCLK ou CLK de l'afficheur est branchée à la broche 12 du 4050
  • La broche LED de l'afficheur n'est pas branchée (je n'avais pas besoin du rétroéclairage).
En résumé, après l'abaissement du niveau logique par le 4050:
  • La broche SCE de l'afficheur reçoit le signal provenant de la broche 4 de l'Arduino
  • La broche RST de l'afficheur reçoit le signal provenant de la broche 3 de l'Arduino
  • La broche D/C de l'afficheur reçoit le signal de la broche 5 de l'Arduino
  • La broche DN/MOSI de l'afficheur reçoit le signal de la broche 11 de l'Arduino
  • La broche SCLK de l'afficheur reçoit le signal de la broche 13 de l'Arduino
Si vous n'avez pas de circuit intégré 4050 sous la main, le tutoriel de Sparkfun propose un moindre mal: insérer une résistance de protection entre les sorties de l'Arduino et l'afficheur (notez que je n'ai pas testé cette option).

Utilisation des bibliothèques:

Au début de votre sketch, lorsque vous définissez les broches de l'Arduino que vous utilisez, vous avez le choix entre deux modes:

Le mode "hardware SPI" (celui que nous avons utilisé, car il est plus rapide). Dans ce mode, les sorties 11 et 13 de l'Arduino sont nécessairement utilisées, et il ne reste qu'à indiquer le numéro des 3 autres broches (dans l'ordre: D/C, SCE ou CS , RST ):

Adafruit_PCD8544 display = Adafruit_PCD8544(5, 4, 3);

Le mode "software SPI" (que certains préfères utiliser, si les sorties 11 et 13 sont déjà affectées à d'autres tâches). Il faut alors indiquer le numéro de toutes les broches utilisées (dans l'ordre: SCLK, DIN ou DN, D/C, SCE ou CS , RST ):

Adafruit_PCD8544 display = Adafruit_PCD8544(7, 6, 5, 4, 3);

De plus, il est important de bien comprendre la numérotation des pixels: la position de chaque pixel est déterminée par une coordonnée x (numéro de colonne) et une coordonnée y (numéro de ligne). La première ligne en haut de l'écran et la première colonne à gauche portent le numéro 0. Ainsi, le premier pixel en haut à gauche se trouve aux coordonnées x = 0, y = 0. Le dernier pixel en bas à droite se trouve aux coordonnées x = 83, y = 47.

Il est possible de contrôler individuellement chacun de ces 4032 pixels, mais c'est rarement nécessaire, car la bibliothèque nous offre des raccourcis utiles pour écrire du texte ou dessiner des formes géométriques à l'écran.

Lorsque vous programmez ce qui apparaîtra à l'écran, les modifications sont d'abord apportées en mémoire, dans un buffer.  Ce n'est que lorsque vous invoquez la commande display() que le contenu du buffer est transposé à l'écran.

clearDisplay() efface à la fois le contenu du buffer et de l'écran.

Écrire du texte

Pour l'écriture de texte à l'écran, on utilise les commandes "print" ou "println" comme lorsqu'on veut faire apparaître un message dans le moniteur série. Par défaut, les polices de caractère ont 5 pixels de largeur et 8 pixels de hauteur, mais on peut grossir les caractères grâce à la commande setTextSize().

       display.setCursor(5, 5);  // le texte commencera à x = 5 et y = 5
       display.setTextColor(BLACK);   // texte en noir
       display.setTextSize(2);   // taille deux fois plus grande que normal
       display.println("Bonjour");   // écriture du texte désiré.
       display.display(); // nécessaire pour que le résultat s'affiche à l'écran

Il existe également une commande qui permet d'afficher un caractère unique:

       display.drawChar(15, 5, 'A',  BLACK, WHITE, 1);

Les arguments de drawChar sont, dans l'ordre: position x, position y, caractère ASCII devant être écrit, couleur du texte, couleur du fond.   La ligne ci-dessus demande donc d'écrire la lettre A à la position x= 15 et y = 5, en noir, sur fond blanc, à la taille par défaut de 5 X 8 pixels.

Dessiner des lignes et des formes géométriques

drawPixel() permet de dessiner un pixel spécifique en noir ou en blanc:

       drawPixel(24, 12, BLACK);  // pour mettre en noir le pixel x = 24, y = 12

drawLine() permet de dessiner une ligne droite:

       display.drawLine(3, 7, 22, 30, BLACK);

(La ligne précédente permet de tracer en noir une ligne droite de la position x = 3 , y = 7 jusqu'à la position x = 22, y = 30.)

drawRect() dessine le contour d'un rectangle (l'intérieur du rectangle demeure transparent):

       display.drawRect(10, 5, 12, 16, BLACK);

(la ligne précédente dessine en noir le contour d'un rectangle dont le coin supérieur gauche se trouve à la position x = 10, y = 5, avec une largeur de 12 pixels et une hauteur de 16 pixels.)

fillRect() dessine un rectangle plein:

       display.fillRect(20, 10, 35, 13, BLACK);

(la ligne précédente dessine un rectangle entièrement noir dont le coin supérieur gauche se trouve à la position x = 20, y = 10, avec une largeur de 35 pixels et une hauteur de 13 pixels.)

drawCircle() dessine le contour d'un cercle:

       display.drawCircle(32, 18, 12, BLACK);

(la ligne précédent dessine en noir le contour d'un cercle dont le centre se trouve à la position x = 32, y = 18, de 12 pixels de rayon).

Avec les mêmes paramètres, fillCircle() dessine un cercle plein.

Pour dessiner un rectangle aux coins arrondis, on utilise drawRoundRect() ou fillRoundRect():

       display.fillRoundRect(8, 12, 43, 17, 6, WHITE);

(la ligne précédente trace un rectangle aux coins arrondi dont le coin supérieur gauche se trouve à la position x = 8, y = 12, de 43 pixels de large et 17 pixels de haut. Les cercles de coin ont un rayon de 6 pixels, et le rectangle est tout blanc (on suppose qu'il est tracé sur fond noir).)

On peut également dessiner un triangle avec drawTriangle() ou fillTriangle():

       display.drawTriangle(5, 31, 10, 18, 34, 25, BLACK);

(la ligne précédente trace le contour d'un triangle dont les 3 coins se trouvent aux positions x= 5, y = 31 , x = 10, y = 18, et x = 34, y = 25).

Afficher une image bitmap

Finalement, la fonction drawBitmap() permet d'afficher à l'écran une image bitmap préalablement stockée en mémoire:

       display.drawBitmap(20, 0, myBitmap, 34, 48, BLACK);

(la ligne précédente dessine l'image stockée dans la variable myBitmap. Il s'agit d'une image de 34 pixels de largeur et de 48 pixels de hauteur, et son coin supérieur gauche doit se situer à la position x = 20, y = 0.)

Encore faut-il définir cette image sous la forme d'octets qui indiquent la couleur (noir ou blanc) de 8 pixels adjacents sur l'écran.  Heureusement, il existe des outils qui permettent de transformer l'image d'un fichier (bmp, jpeg ou autre) en un tableau prêt à être utilisé dans votre programme.

À cet effet, je vous recommande l'outil en ligne image2ccp.

Vous sélectionnez d'abord le fichier contenant l'image que vous désirez afficher.


Vous réglez ensuite différents paramètres (taille désirée, etc).


Vous sélectionnez le type de code désiré ("Arduino code, single bitmap"), choisissez le nom désiré pour la variable, puis cliquez sur le bouton "Générate code": il ne reste plus qu'à copier le résultat et le coller dans votre sketch Arduino!



Sketch d'exemple

Voici un sketch dans lequel j'utilise tout ce qui a été mentionné dans cet article.


Résultat

Finalement, une courte vidéo montrant l'afficheur pendant l'exécution du sketch.




Yves Pelletier   (TwitterFacebook)


Related Posts Plugin for WordPress, Blogger...