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 (Twitter, Facebook)
(avec la précieuse collaboration de Zachary Pelletier)
À 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.
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.
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
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).
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.
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.
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.
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.
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).
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 ):
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 ):
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():
(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.
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.
Je vous présente aujourd'hui deux livres qui proposent à un jeune public des activités d'initiation à la programmation, à l'électronique et à la robotique au moyen du logiciel mBlock: Arduino pour les kids, par Frédéric Pain, et 36 activités avec le robot mBot, par Dominique Nibart.
mBlock est un logiciel qui permet de programmer un microcontrôleur (Arduino, micro:bit, mBot, etc.) en utilisant le langage Scratch: il s'agit de faire glisser à l'écran des blocs représentant des bouts de programme, et de les imbriquer de façon à obtenir un programme complet. Puisque l'utilisateur n'a pas à apprendre la syntaxe du langage, il s'agit d'une façon simple et amusante d'initier les écoliers à la programmation.
(Je n'ai encore jamais eu l'occasion d'expérimenter mBlock, mais je vous ai déjà parlé de S4A et de Blockly@rduino, qui sont similaires).
Ce petit livre a pour objectifs d'initier les écoliers de 8 ans et plus aux bases de la programmation et de l'électronique. En programmant une carte Arduino au moyen de mBlock, ils apprennent à faire clignoter une LED et à faire varier sa luminosité, à lire un potentiomètre ou une photorésistance, mesurer une température, etc. Comme il se doit, les activités sont amusantes (déplacer un personnage animé au moyen d'un joystick, par exemple).
Des encadrés (dont la lecture n'est pas obligatoire pour réaliser les activités) présentent des explications supplémentaires pour mieux comprendre le comportement des circuits (PWM, utilisation de la loi d'Ohm).
Bien sûr, compte tenu de la jeunesse du public cible, il ne faut pas s'attendre à l'équivalent d'un manuel complet sur l'Arduino: chacun des 7 montages présentés est extrêmement simple. (Si vous cherchez à assouvir la soif de connaissance d'un enfant un peu plus vieux, le livre À l'aventure avec Arduino sera peut-être plus approprié).
Comme son titre l'indique, ce livre présente un grand nombre d'activités à réaliser avec le robot mBot. Il s'adresse au élèves du primaire, des collèges et des lycées.
mBot est petit robot sur roues commercialisé par la compagnie MakeBlock, et qui se programme avec au moyen du logiciel mBlock. Il comporte une télécommande, un télémètre à ultrasons et un module de détection de lignes, mais il est également possible de lui ajouter des capteurs supplémentaires.
Sans trop de surprise, on y apprendra comment programmer le robot pour qu'il se déplace en suivant une ligne ou en évitant les obstacles, mais on est également invités à lui faire accomplir des actions qui sont moins traditionnellement associées aux robots, comme jouer de la musique ou produire des animations sur une matrice de LEDs.
Le livre va droit au but, sans digressions inutiles: la plupart des projets sont présentés en une seule page comportant un bref paragraphe d'introduction, un résumé de l'algorithme et le programme lui-même (généralement très court, puisqu'il s'agit d'accomplir une action spécifique).
Aujourd'hui, je vous glisse quelques mots concernant un oscilloscope de poche DSO150 acheté sous forme de kit. (Prix payé: 19 USD, frais de port inclus.)
Le kit est constitué de deux cartes sur lesquelles de nombreux composants montés en surface on déjà été soudés, d'une douzaine de composants traversants à souder soi-même, d'un boîtier en plastique, de câbles pour la prise de mesure et d'un manuel d'instructions.
Pour fonctionner, l'oscilloscope nécessite toutefois une alimentation en courant continu de 9 V, et cette dernière n'est pas fournie.
Le manuel d'instructions est assez bien fait: les photographies en couleur sont très claires, et l'anglais est tout à fait compréhensible. Le seul inconvénient (mineur), c'est qu'il y a une seule version du manuel pour les deux versions possibles du kit: celle où on doit aussi souder les composants montés en surface, et celle où les composants montés en surface sont déjà soudés. Certaines étapes sont donc superflues lorsqu'on a la version la plus simple du kit. Le manuel prétend aussi que nous devons nous-mêmes souder 15 résistances et 4 condensateurs céramique sur la carte analogique alors que dans mon kit, tout ça était déjà installé.
Après avoir vérifié le fonctionnement correct de l'écran couleur, on soude 8 composants sur la carte principale: le connecteur pour le signal de test, un connecteur d'alimentation secondaire (qui deviendra inaccessible lorsque nous aurons assemblé le boîtier!), un interrupteur marche/arrêt, une barrette de 4 broches (qui servira plus tard à brancher le codeur rotatif), et 4 gros boutons poussoirs. De plus, il faut retirer la résistance R30, dont l'unique fonction a été de nous permettre de vérifier le bon fonctionnement de l'écran avant d'avoir soudé l'interrupteur marche/arrêt.
Nous passons ensuite à la carte analogique. Nous devons y souder trois condensateurs électrolytiques, un commutateur à 3 positions (AC-DC-GND), le connecteur BNC qui nous permettra de prendre des mesures et une barrette comportant deux rangées de 5 broches (ces broches feront le lien entre la carte principale et la carte analogique).
Ensuite, on soude le codeur rotatif sur la petite carte qui lui est destinée...
...qu'on visse et soude à la carte principale.
Roulement de tambour...c'est le moment de vérifier que toutes nos soudures sont bien réussies: on assemble la carte analogique à la carte principale (en insérant les 10 broches mâles de la carte analogique dans les 10 connecteurs femelles de la carte principale), on allume l'appareil, on place le commutateur en position GND, et on mesure la tension à 8 endroits. Si les tensions mesurées correspondent à celles qui sont indiquées à l'étape 4 des instructions, tout va bien et l'assemblage est presque terminé. Sinon, on révise nos soudures... (à la toute fin du manuel, la section "troubleshooting" indique la cause probable de chaque mauvaise mesure).
Il y a aussi deux condensateurs variables C3 et C5 qu'on doit ajuster avec un petit tournevis pour éviter une déformation du signal à l'écran.
Il ne reste plus qu'à assembler le boîtier...
... et notre oscilloscope est prêt à être utilisé!
L'utilisation est assez simple: pour ajuster l'échelle de l'ordonnée, on appuie sur le bouton V/DIV, et on tourne le codeur rotatif. Pour ajuster l'échelle de l'abscisse, on appuie sur le bouton SEC/DIV et on tourne le codeur rotatif. Le bouton TRIGGER permet de modifier le mode de déclenchement horizontal, et le bouton OK permet de figer l'affichage pour que ça cesse de bouger. Si on appuie au moins 3 secondes sur le bouton OK, une liste de paramètres numériques apparaissent à l'écran:
Parmi les points forts de l'oscilloscope, nous pouvons citer:
son prix!
sa petite taille (la nécessité de lui adjoindre une alimentation 9 V le rend un tout petit peu moins portable, mais ce truc demeure tout de même plus petit qu'on multimètre!)
sa facilité d'utilisation
la possibilité de mesurer un signal d'une amplitude maximale de 50 V
le plaisir de participer à la construction de l'appareil, même s'il faut bien admettre que l'essentiel du travail avait déjà été accompli en usine.
Mais soyons réaliste, il ne s'agit aucunement d'un appareil de mesure destiné aux professionnels. Parmi les inconvénients notables:
la bande passante de 200 kHz en fait un appareil plutôt lent. C'est acceptable si on désire visualiser un signal PWM ou un signal de fréquence audible, mais ça peut devenir un inconvénient important pour des signaux plus rapides.
Il n'y a qu'un seul canal, on ne peut donc y brancher qu'une seule sonde. Bien difficile, donc, de comparer entre eux deux signaux différents, mesurer un déphasage, etc.
L'écran est très, très petit.
Je ne suis pas convaincu que les petits interrupteurs à glissière pourront tenir le coup éternellement (bien sûr, je pourrai les remplacer au besoin).
Donc, un gadget utile pour certaines applications, mais qui ne doit pas être considéré comme l'équivalent d'un véritable oscilloscope de bonne qualité. Si vous n'avez pas les moyens de vous procurer un tel oscilloscope, c'est certainement mieux que rien du tout...
Lorsque vous créez un objet connecté au moyen d'un ESP8266 ou d'un ESP32, il est parfois utile que votre dispositif soit en mesure d'afficher un court message de façon autonome, ne serait-ce que pour indiquer que sa tentative de connexion au réseau WiFi n'a pas fonctionné, pour afficher son adresse IP, etc.
C'est pourquoi je vous présente aujourd'hui un court article sur le contrôle d'un afficheur à cristaux liquides 16 X 2 basé sur le contrôleur Hitachi HD44780, au moyen d'un module ESP8266 ou ESP32.
Préparation de l'IDE Arduino
Nous allons programmer l'ESP au moyen de l'IDE Arduino. Les fichiers nécessaires à la programmation de ce module doivent donc avoir été ajoutés au moyen du gestionnaire de cartes du logiciel; pour plus d'informations à ce sujet, voir voir cet article pour l'ESP8266 ou celui-ci pour l'ESP32.
Connexions
L'afficheur LCD occupe 6 broches de l'ESP, sans compter l'alimentation. Assurez-vous d'utiliser un afficheur qui accepte de fonctionner à un niveau logique de 3,3 V, car ce n'est pas toujours le cas. De plus, si vous programmez le module avec un convertisseur USB-série, il est très important qu'il s'agisse d'un modèle fonctionnant sous 3,3 V, et non 5 V.
Les 16 broches de l'afficheur LCD sont connectées de la façon suivante:
Broche 1 de l'afficheur (VSS): GND
Broche 2 de l'afficheur (VDD): 3,3 V
Broche 3 de l'afficheur (contraste): potentiomètre variant de 0 à 3,3 V.
Broche 4 de l'afficheur (RS): broche GPIO4 de l'ESP8266
Broche 5 de l'afficheur (RW): GND
Broche 6 de l'afficheur (E): GPIO05 de l'ESP8266
Broches 7, 8, 9 et 10 de l'afficheur (D0, D1, D2, D3): pas connectées
Broche 11 de l'afficheur (D4): GPIO12 de l'ESP8266
Broche 12 de l'afficheur (D5): GPIO13 de l'ESP8266
Broche 13 de l'afficheur (D6): GPIO14 de l'ESP8266
Broche 14 de l'afficheur (D7): GPIO15 de l'ESP8266
Broche 15 de l'afficheur (rétroéclairage): 3,3 V
Broche 16 de l'afficheur: GND
Ce qui donne ce résultat avec ma carte de développement ESP32:
...et celui-ci avec une carte Wemo D1 Mini:
De plus, si vous utilisez un module ESP8266 qui n'est pas intégré à une carte de développement (genre NodeMCU ou Wemos), vous devrez, comme d'habitude, brancher ses broches VCC, RST et CH_PD (enable) à 3,3 V, et brancher ses broches GND et GPIO0 à GND. La broche TXD de l'ESP8266 se branche sur le RX du convertisseur USB-série, et la broche RXD de l'ESP8266 se branche sur le TX du convertisseur USB-série.
Sketch minimal
Bonne nouvelle: si vous avez déjà utilisé ce type d'afficheur avec une carte Arduino, ce sera exactement la même chose, puisque la bibliothèque LiquidCrystal fournie avec l'IDE Arduino est pleinement compatible avec l'ESP8266.
Voici un premier sketch qui ne fait que le strict minimum: afficher un message sur l'afficheur LCD.
Affichage d'un message éditable par une page web
Essayons maintenant un mini-projet qui utilisera un peu mieux les caractéristiques de l'ESP8266 / ESP32: le message qui sera affiché par le LCD pourra être modifié à distance au moyen d'une page web.
Au démarrage du sketch, l'ESP8266 se connecte au réseau WiFi et son adresse IP s'affiche dans le moniteur série de l'IDE Arduino. Il s'agit de coller cette adresse IP dans le navigateur web d'un appareil (ordinateur ou téléphone) branché au même réseau local pour faire apparaître une page web générée par l'ESP8266.
Vous écrivez un message dans les champs de texte de la page web (un champ pour chaque ligne du LCD) et, lorsque vous cliquez sur le bouton "Appliquer", le message s'affiche sur le LCD.
