dimanche 24 février 2019

Capteur de lumière TSL2561 et Raspberry Pi

Le capteur de lumière TSL2561 permet de mesurer l'intensité lumineuse avec une très bonne précision. Il comporte en fait deux capteurs: un capteur large bande qui réagit à la lumière visible et à la lumière infrarouge, et un deuxième capteur qui ne réagit qu'à l'infrarouge. Au moyen des deux valeurs mesurées, il est possible de calculer l'éclairement en lux. Nous avons déjà eu l'occasion d'utiliser un de ces modules avec un Arduino mais voyons maintenant ce que nous pouvons en tirer si nous le connectons à un Raspberry Pi, que nous programmerons en Python

Connexion du module TSL2561 au Raspberry Pi


Puisqu'il s'agit d'un capteur I2C, nous utilisons les broches du Raspberry Pi qui sont dédiées à ce type de communication.

                                             Module TSL2561  ----------    Raspberry Pi
                                                         VCC   ---------------   Broche 1 (3,3 V)
                                                         GND   ---------------- Broche 6 (GND)
                                                         SCL     --------------   Broche 5 (GPIO3)
                                                         SDA    ---------------  Broche 3 (GPIO2)
                                                         INT      -------------    pas branché


Préparation du Raspberry Pi pour la communication i2c

La communication i2c doit avoir été activée sur votre Raspberry Pi. Pour ce faire, il s'agit d'aller dans le menu "Préférences / Configuration du Raspberry Pi".


On sélectionne ensuite "Activé" sur la ligne "I2C", et on redémarre le Raspberry Pi.


Si le module TSL2561 est correctement branché à votre Raspberry Pi, vous devriez le voir à l'adresse 39 en entrant la commande "i2cdetect -y 1" dans le Terminal.


Bibliothèque

Il n'est pas très difficile de récupérer les données brutes issues des deux capteurs du TSL2561, mais leur conversion en lux est assez délicate, et j'ai donc préféré utiliser une bibliothèque conçue par Keiichi Shima.  De tous ces fichiers présents dans cette collection, seuls tsl2561.py et sensorbase.py sont nécessaires.

Script 1: affichage des données dans le terminal

Commençons par un premier exemple minimaliste: une fois par seconde, l'intensité lumineuse mesurée par le capteur est affichée dans le terminal. Il est facile de faire varier la valeur affichée en couvrant le capteur, en le dirigeant vers une source lumineuse, etc.





Script 2: affichage dans une fenêtre avec Tkinter (interface graphique)

Dans ce deuxième exemple, j'ai utilisé Tkinter afin d'afficher la valeur mesurée dans une fenêtre plus élégante. Grâce à la méthode "after" de Tkinter, la valeur affichée se met à jour chaque seconde.




Script 3: datalogging dans un fichier csv

Finalement, ce troisième script consigne les mesures à l'intérieur d'un fichier intitulé "luminosité.csv", qui est créé dans le même répertoire que le script python, et qui peut ensuite être ouvert avec LibreOffice Calc.

La capture d'écran ci-dessus montre le résultat pendant que le soleil se lève, un matin d'hiver nuageux. La première colonne contient le moment de la mesure (en secondes), et la deuxième colonne contient la valeur mesurée en lux.





Yves Pelletier   (TwitterFacebook)

samedi 16 février 2019

Bras robotique Tinkerkit Braccio


J'ai eu l'occasion de faire l'essai du bras robotique Braccio, qui est spécialement conçu pour être utilisé avec une carte Arduino.

La boîte contient tout ce qui est nécessaire pour assembler un bras fonctionnel...sauf la carte Arduino, qui doit être achetée séparément (un modèle fonctionnement à un niveau logique de 5 V, comme par exemple le Uno, est nécessaire).

Assemblage

Le Braccio arrive en pièces détachées: une vingtaine de pièces de plastiques qui doivent être assemblées au moyen d'une soixantaine de vis (un tournevis cruciforme tout à fait conventionnel est fourni dans le kit, ce qui m'a semblé un peu discutable), 6 servomoteurs, une alimentation (5 V, 4 A) et le shield Braccio.


Les instructions d'assemblage fournies dans la boîte ressemblent à celles qui accompagnent un kit Lego: des illustrations, raisonnablement claires, et pas le moindre texte. En cas d'incertitude, des vidéos d'assemblage sont disponibles sur YouTube (celui-ci me semble très bien).

On commence par assembler la partie du bras se situant entre l'épaule et le coude (servomoteurs M2 et M3).





Le servomoteur M1 est fixé à la base.


L'épaule est reliée à la base rotative.


Assemblage de l'avant-bras (servomoteur M4).




On ajoute le poignet (servomoteur M5).




Assemblage de la pince (servomoteur M6)



Le shield Braccio V4

Le shield Braccio comporte 6 connecteurs de couleur orange auxquels vous branchez les servomoteurs (vous les insérez dans l'ordre, M1 étant situé du côté du jack d'alimentation).

Les connecteurs blancs permettent de brancher des capteurs analogiques (ils sont reliés aux entrées A0 à A5 de l'Arduino). Le connecteur jaune est pour la communication série, et le vert ("TWI") pour un capteur I2C.


Le bloc d'alimentation (5 V, 4 A) doit être branché au shield Braccio. Il supporte une tension d'entrée allant de 100 à 240 V, 50 ou 60 Hz.


Le shield Braccio doit être superposé à une carte Arduino qui fonctionne à un niveau logique de 5 V (Uno, par exemple).

La bibliothèque Braccio

Une bibliothèque spécialement conçue pour le contrôle du Braccio est disponible ici.

Une fois la bibliothèque installée, le premier exemple à essayer est testBraccio90, qui place le Braccio en position verticale, pour vérifier si tous les servomoteurs sont correctement alignés. Vous pouvez ensuite essayer les exemples simpleMovements et takethesponge.



Programmation

Mise à part la commande d'initialisation du Braccio ("Braccio.begin()" qui doit doit être placée dans "setup()"), tous les mouvements du Braccio sont contrôlés par une même commande:

Braccio.ServoMovement((step delay  M1 , M2 , M3 , M4 , M5 , M6);

  • Le premier paramètre (step delay) est le nombre de millisecondes de pause entre le mouvement de chaque servo. Les valeurs admises vont de 10 à 30.
  • M1 est l'angle de la base rotative, en degrés. Les valeurs admises vont de 0 à 180.
  • M2 est l'angle de l'épaule, en degrés. Les valeurs admises vont de 15 à 165.
  • M3 est l'angle du coude, en degrés. Les valeurs admises vont de 0 à 180.
  • M4 est l'articulation du poignet. Les valeurs admises vont de 0 à 180.
  • M5 contrôle la rotation de la pince. Les valeurs admises vont de 0 à 180.
  • M6 permet d'ouvrir ou fermer la pince. Les valeurs admises vont de 10° (complètement ouverte) à 73° (complètement fermée).
C'est une bonne idée, dans un premier temps, de faire bouger chaque servomoteur un par un, afin de bien visualiser ce que contrôle chaque paramètre, et pour vérifier que le mouvement peut bel et bien s'effectuer sur toute la plage des valeurs admissibles.

Résultats

Pour finir, une courte vidéo du Braccio qui s'amuse avec une éponge.




Yves Pelletier   (TwitterFacebook)

vendredi 15 février 2019

Et pendant ce temps, dans un blog près de chez vous...(1)

J'ai publié beaucoup de nouveaux articles au cours des dernières semaines, mais je ne suis pas le seul! Voici une sélection de billets publiés dans d'autres blogs en français depuis le début de l'année 2019:
Voilà qui devrait contribuer à assouvir votre soif d'informations pour un certain temps.  N'hésitez pas à me faire part de blogs en français qui mériteraient d'être mentionnés dans une éventuelle prochaine livraison de cette chronique. J'ai volontairement omis les chaînes YouTube, car je n'ai pas la patience de regarder des vidéos: je préfère de loin lire du texte et regarder des schémas.

Yves Pelletier   (TwitterFacebook)

mercredi 13 février 2019

Écran Nokia 5110 et MSP430 Launchpad

Dans ce billet, nous faisons fonctionner un petit écran monochrome de type "Nokia 5110" branché à un MSP430 Launchpad que nous programmons avec Energia.


 (N'hésitez pas à consulter mes précédents billets si vous souhaitez plutôt brancher cet écran à un Arduino ou à un Raspberry Pi).

Installation de la bibliothèque LCD_5110

Comme c'est trop souvent le cas avec le Launchpad, le lien officiel vers la bibliothèque LCD_5110 mise au point en 2012 par Rei Vilo n'est plus valide, ce qui a quelque peu compliqué mes recherches.  Je vous propose ce fichier zip, gracieuseté du blog de Joe Freeman. En plus des 4 fichiers qui constituent la bibliothèque LCD_5110 (LCD_5110.h, LCD_5110.cpp, Terminal6.h et Terminal12.h), l'archive inclut également un petit programme qui affiche la température sur l'écran Nokia (LCD_5110_430.ino) et une deuxième bibliothèque permettant de lire la température du msp430 (Thermometer_430.h et Thermometer_430.cpp). Si par hasard le lien devenait invalide, vous pouvez aussi trouver les fichier nécessaires sur le dépôt github de cyoung.

Notez que, puisque cette bibliothèque a été conçue pour les versions bas de gamme du Launchpad (qui ont une mémoire limitée), elle permet uniquement d'afficher du texte à l'écran. Vous ne pouvez pas l'utiliser pour dessiner des formes géométriques, afficher des images bitmap, etc (si c'est ce qui vous intéresse, et à la condition de disposer d'un Launchpad suffisamment puissant, cette autre bibliothèque, que je n'ai pas testée, pourrait vous intéresser).

Modification de la bibliothèque

Les modèles de Launchpad n'étaient pas très nombreux en 2012, et l'auteur de la bibliothèque n'a donc prévu que trois options possibles:  MSP430G2452, MSP430G2553 et MSP430G2231. Si vous désirez utiliser la bibliothèque avec un modèle plus récent, une petite modification au fichier "LCD_5110.h" s'avère nécessaire.

À la ligne #20, le fichier Energia.h est inclus à la condition que vous compiliez le programme pour un des trois microcontrôleurs pré-cités:


J'ai réglé le problème en retirant la condition "#elif defined(__MSP430G2452__) || defined(__MSP430G2553__) || defined(__MSP430G2231__)" afin que l'instruction #include "Energia.h" soit toujours exécutée, peu importe le modèle de Launchpad.

J'ai testé avec succès cette version modifiée de la bibliothèque avec trois modèles de Launchpad: le classique MSP-EXP430G2 (comportant le MSP430G2553), le MSP430FR2433, et le Stellaris (lm4f120).

Connexions

Vous pouvez utiliser les broches que vous voulez, elles seront déclarées dans le sketch. Voici celles que j'ai utilisées:
  • Broche 1. VCC du module Nokia 5110 --- VCC (3,3 V) du Launchpad
  • Broche 2. GND du module Nokia 5110 --- GND du Launchpad
  • Broche 3. SCE (chip select) du module Nokia 5110 --- P1.4 du Launchpad
  • Broche 4. RST du module Nokia 5110 --- P1.5 du Launchpad
  • Broche 5. D/C du module Nokia 5110 --- P2.0 du Launchpad
  • Broche 6. DN (MOSI) du module Nokia 5110 --- P2.1 du Launchpad
  • Broche 7. SCLK du module Nokia 5110 --- P2.4 du Launchpad
  • Broche 8. LED du module Nokia 5110 (rétroéclairage) --- je ne l'ai pas branchée

Sketch

Les principales méthodes de la classe "LCD_5110" sont:
  • begin() : initialisation de l'écran
  • clear() : efface le contenu entier de l'écran
  • setFont(int taille): règle la taille de la police de caractère (0 pour taille normale, 1 ou 2 pour plus gros).
  • text(int x, int y, "texte à afficher"): écriture d'une chaîne de caractères à la position x, y

Voici un sketch qui affiche un nombre entier qui augmente d'une unité à chaque seconde. Les parties statiques (en haut et en bas de l'écran) sont écrites au démarrage du programme (dans setup()) alors que le nombre est mis à jour à l'intérieur du loop().

Un aspect intéressant de cette bibliothèque, c'est qu'il n'est pas nécessaire d'effacer le nombre précédent avant d'écrire le nouveau nombre: ce que vous écrivez remplace simplement ce qui était précédemment écrit à la même position.

Pour me compliquer un peu la vie, j'ai choisi de centrer le nombre horizontalement, ce qui m'oblige à déterminer le nombre de chiffres à afficher avant de décider de l'endroit, sur l'écran, où j'écris le nombre.


Yves Pelletier   (TwitterFacebook)

dimanche 10 février 2019

Écran couleur KMR-1.8 SPI (ST7735) et Arduino

Après avoir récemment expérimenté le contrôle de deux petits écrans monochromes avec un Arduino Uno (Nokia 5110 et OLED SH1106), j'explore aujourd'hui un petit écran couleur TFT "KMR-1.8 SPI". Comme son nom l'indique, il s'agit d'un écran de 1,8" (définition 128*160) utilisant le protocole SPI.


Mon modèle est muni d'un pilote ST7735. Toutefois, d'autres écrans en apparence identiques utilisent plutôt le pilote S6D02A1 ou encore le ILI9163. Il existe une bibliothèque pour chacune de ces versions, et il faut parfois toutes les essayer lorsqu'on ignore le numéro du pilote se trouvant sur notre écran.

Au verso de l'écran, on trouve un lecteur de carte SD (que je n'ai pas utilisé pour l'instant). Le module comporte pas moins de 16 connecteurs (à souder soi-même, bien entendu), dont le marquage laisse parfois à désirer (il est bien difficile de deviner, sans documentation, quelles broches concernent le lecteur de carte SD plutôt que l'écran).


Connexions

Mon module comporte un régulateur de tension 65z5 (portant la désignation "U2" sur le circuit imprimé) qui permet d'alimenter le module avec une tension de 5 V (si vous préférez l'alimenter avec 3,3 V, il faut fermer le jumper "JP1"), mais les autres entrées ne bénéficient pas de cette protection et sont conçues pour fonctionner à un niveau logique de 3,3 V.

Ma première intention était d'utiliser un circuit intégré 4050 pour abaisser à 3,3 V les signaux logiques de l'Arduino Uno, mais pour une raison que j'ignore le résultat s'est révélé très instable: l'écran devenait soudainement totalement blanc, sans raison apparente, et le seul remède consistait à appuyer sur le bouton reset de l'Arduino pour redémarrer le programme. J'ai cru que le courant requis par l'écran était possiblement trop élevé pour le régulateur 3,3 V de l'Arduino, mais les résultats n'étaient pas meilleurs en utilisant une source de tension externe de 3,3 V.

Je vous présente donc les connexions conseillées par Bodmer, qui est également l'auteur de la bibliothèque que je vous recommande un peu plus loin dans ce même article: les signaux logiques sont abaissés au moyen d'un simple diviseur de tension constituée d'une résistance de 2,2 kΩ (située entre la masse GND et l'entrée de l'écran, et d'une résistance de 1,2 kΩ (située entre la même entrée de l'écran et la sortie de l'Arduino). 10 résistances sont donc requises, puisqu'il faut protéger de cette façon 5 entrées de l'écran.

En énumérant les broches dans le même ordre que sur le module TFT, ça donne ceci:
  • #1 GND du KMR-1.8: GND de l'Arduino
  • #2 VCC du KMR-1.8: 5V de l'Arduino
  • #3 NC du KMR-1.8: Pas branché
  • #4 NC du KMR-1.8: Pas branché
  • #5 NC du KMR-1.8: Pas branché
  • #6 RESET du KMR-1.8: sortie 7 de l'Arduino (via 2,2 kΩ) et GND (via 1,2 kΩ)
  • #7 AO du KMR-1.8: sortie 8  de l'Arduino (via 2,2 kΩ) et GND (via 1,2 kΩ)
  • #8 SDA du KMR-1.8: sortie 11 de l'Arduino (via 2,2 kΩ) et GND (via 1,2 kΩ)
  • #9 SCL du KMR-1.8: sortie 13 de l'Arduino (via 2,2 kΩ) et GND (via 1,2 kΩ)
  • #10 CS du KMR-1.8: sortie 9 de de l'Arduino (via 2,2 kΩ) et GND (via 1,2 kΩ)
  • #11 SCK du KMR-1.8: pas branché (lecteur de carte SD)
  • #12 MISO du KMR-1.8: pas branché (lecteur de carte SD)
  • #13 MOSI du KMR-1.8: pas branché (lecteur de carte SD)
  • #14 SD_CS du KMR-1.8: pas branché (lecteur de carte SD)
  • #15 LED+ du KMR-1.8: 5 V (via une résistance de  270 Ω)
  • #16 LED- du KMR-1.8: GND
Pour le rétroéclairage, j'ai utilisé une résistance de 270 Ω soit bien plus que la valeur minimale de 22 Ω conseillée par Bodmer. Je n'ai pas constaté de différence notable à l'écran.

Je rappelle que je n'ai pas utilisé le lecteur de carte SD pour l'instant, ce qui explique pourquoi les broches 11, 12, 13 et 14 n'ont pas été connectées.


Il est sans doute pertinent de mentionner que si ce montage fonctionne de façon irréprochable avec une de mes cartes Arduino Uno, il ne fonctionne pas du tout avec un autre Uno en apparence identique: l'écran demeure obstinément blanc (j'admets qu'il s'agit de deux clones chinois, mais quand même...).

Installation de la bibliothèque

Comme je le mentionnais un peu plus haut, j'ai utilisé la bibliothèque TFT_ST7735 mise au point par Bodmer. Il est possible, cependant, que votre module nécessite plutôt la bibliothèque TFT_S6D02A1 ou encore la bibliothèque TFT_ILI9163. Tout va bien si le vendeur de votre écran a indiqué dans sa description le bon modèle de pilote, sinon il faudra les essayer une par une jusqu'à ce que ça fonctionne!

La bibliothèque est accompagnée de plus d'une dizaine d'exemples qui permettent de vérifier rapidement le bon fonctionnement de l'écran.

Réglage de paramètres dans la bibliothèque

Lorsque j'ai testé mon écran, j'ai constaté que l'image apparaissant à l'écran était décalée de quelques pixels: on pouvait voir une mince bande de pixels multicolores dans le haut de l'écran, ainsi que sur le côté gauche.

Image décalée
Pas de panique: on peut rapidement régler le problème en modifiant les paramètres par défaut de la bibliothèque.

Après ajustement des paramètres de la bibliothèque
Il s'agit d'ouvrir le fichier "User_Setup.h" situé dans le répertoire de la bibliothèque TFT_ST7735.  Cinq options sont proposées pour la définition de la variable "TAB_COLOUR" (qui représente apparemment la couleur de l'onglet de la pellicule protectrice qui recouvrait l'écran lors de l'achat).  Par défaut, TAB_COLOUR est réglée à INITR_GREENTAB2.


Puisque j'avais jeté la pellicule protectrice sans porter attention à la couleur de son onglet, j'ai essayé toutes les options l'une après l'autre. La plupart d'entre elles empiraient la situation (l'écran n'affichait pas les bonnes couleurs!) mais l'option "INITR_BLACKTAB" convenait parfaitement à mon écran.


Ce même fichier (User_Setup.h) vous permet également de modifier le numéro des broches de l'Arduino que vous désirez utiliser, ou de ne pas charger certaines tailles de police afin d'économiser de la mémoire.

Un exemple de sketch

Pour finir, je vous présente un sketch qui affiche à l'écran la valeur numérique de tension mesurée à l'entrée A0 de l'Arduino, avec une jauge linéaire (vous pouvez tester ce sketch en branchant un potentiomètre à l'entrée A0). La bibliothèque de Bodmer propose une méthode "drawFloat" spécialement conçue pour l'affichage d'une valeur décimale, ce qui a beaucoup simplifié les choses, puisqu'elle s'occupe même de l'arrondissement à la précision requise:

drawFloat(valeur_numerique, nombre_de_décimales, position_x, position_y, taille_de_police);

Par défaut, l'écran est prévu pour une utilisation en mode portrait. Puisque je désirais l'utiliser en mode paysage, il a été nécessaire d'inclure l'instruction "setRotation(1)" au démarrage.

Lorsque j'avais expérimenté des écrans monochromes (Nokia et OLED), je construisais d'abord l'image dans un buffer, puis je l'affichais à l'écran lorsqu'elle était prête. Je pouvais ensuite effacer le buffer pour reconstruire une nouvelle image à partir de zéro. Pour cet écran couleur, toutefois, on dessine directement à l'écran (je suppose que la taille du buffer serait trop grande). Pour éviter autant que possible des clignotements très désagréables, il faut essayer de ne mettre à jour que les zones de l'écran qui doivent être changées, plutôt que redessiner la totalité de l'image. J'obtiens donc de bien meilleurs résultats en réécrivant l'ancienne valeur numérique en noir (sur fond noir) pour l'effacer, plutôt qu'en la recouvrant d'un rectangle noir.



À lire aussi

Si vous préférez, il est possible de contrôler cet écran avec un STM32 , un ESP32 ou un ESP8266 (ces cartes ont l'avantage de fonctionner à un niveau logique de 3,3 V, beaucoup mieux adapté à l'écran).

D'autres écrans peuvent évidemment être pilotés par une carte Arduino, comme par exemple les modèles Nokia 5110 ou OLED SH1106.

D'autre part, vous trouverez sur cette page la liste des projets impliquant l'Arduino.

Yves Pelletier   (TwitterFacebook)

mercredi 6 février 2019

Carte SD et Blue Pill (STM32Duino)

Je continue mon exploration de la carte STM32F103 "Blue Pill" en l'associant, cette fois-ci,  à un lecteur de carte SD, afin d'écrire et lire des fichiers sur une carte SD.

Comme d'habitude, j'utiliserai l'IDE Arduino pour programmer la carte (la marche à suivre a été expliquée ici).

Mon lecteur de carte SD est un module qui communique au moyen du protocole SPI. C'est le modèle économique qu'on trouve facilement sur les sites de vente asiatiques. Il est conçu pour être utilisé à un niveau logique de 3,3 V, ce qui est parfait pour notre Blue Pill.

Connexions

Le module lecteur de carte SD est branché à la Blue Pill de la façon suivante:
  • GND du module carte SD --- GND de la Blue Pill
  • +3.3 du module carte SD --- 3.3 de la Blue Pill
  • +5 du module carte SD --- pas connecté
  • CS du module carte SD --- A4 de la Blue Pill
  • MOSI du module carte SD --- A7 de la Blue Pill
  • SCK du module carte SD --- A5 de la Blue Pill
  • MISO du module carte SD --- A6 de la Blue Pill


Vérification du bon fonctionnement

Une fois le lecteur de carte SD branché à la Blue Pill, l'exemple "CardInfo" de la bibliothèque "SD" est la première chose à essayer: il permet de vérifier que tout fonctionne correctement (notez qu'il n'est pas nécessaire d'installer la bibliothèque SD: il s'agit d'une bibliothèque déjà incluse par défaut avec l'IDE Arduino).



La seule modification à apporter au sketch "Cardinfo" est le numéro de la broche utilisée pour le "chip select", à la ligne 36: il faut remplacer "4" par "PA4":

const int chipSelect = PA4;

Si tout va bien, le moniteur série de l'IDE Arduino devrait montrer un message donnant diverses informations concernant la carte SD insérée dans le lecteur.


Si vous obtenez plutôt un message du genre "initialization failed", il y a un problème quelque part (et il faut le régler). Ces modules pour cartes SD ont la réputation d'être capricieux. Parfois, ça fonctionne avec une carte, et pas avec une autre!


Écriture et lecture d'un fichier

L'exemple "ReadWrite", situé dans le même répertoire que "CardInfo" montre assez clairement comment procéder pour écrire à l'intérieur d'un fichier texte sur la carte SD. Je vous propose ci-dessous une variante commentée en français et prête à être utilisée sans modifications sur votre Blue Pill.

Nous branchons deux boutons poussoir à la Blue Pill: un bouton qui nous permettra d'écrire quelque chose dans un fichier chaque fois qu'il sera enfoncé, et un deuxième bouton qui lira le contenu du fichier (et le transmettra au moniteur série) chaque fois qu'il sera enfoncé.  J'ai branché ces boutons (associés à des résistances pull-down) aux broches B12 et B13 de la Blue Pill.




La bibliothèque SD permet d'interagir avec notre fichier sans trop de difficulté:
  • File monFichier: création d'une variable de type "File" nommée "monFichier".
  • SD.begin(PA4): Initialise la communication avec la carte, PA4 étant la broche de la Blue Pill reliée à la broche "chip select" du lecteur de carte.
  • monFichier = SD.open("Archives.txt", FILE_WRITE) : Ouverture du fichier texte intitulé "Archives.txt", dans le but de modifier son contenu. Si ce fichier n'existe pas, il sera créé, puis ouvert.
  • monFichier.print("Valeur du compteur:  "): écriture des mots "Valeur du compteur:  " à l'intérieur du fichier actuellement ouvert (qui est "Archives.txt").
  • monFichier.println(compteur): écriture de la valeur numérique de la variable "compteur" dans le fichier actuellement ouvert, suivi d'un saut de ligne.
  • monFichier.close(): fermeture du fichier.
  • SD.open("Archives.txt"): ouverture du fichier texte "Archives.txt" dans le but de le lire.
  • monFichier.available(): retourne le nombre de bytes du fichier disponibles pour la lecture
  • monFichier.read(): retourne le prochain caractère à lire dans le fichier (ou -1 s'il ne reste plus rien à lire).
  • monFichier.close(): fermeture du fichier.
Il est important de toujours ouvrir le fichier avant de pouvoir le lire ou y écrire, et on n'oublie pas de le refermer ensuite.

Je n'ai pas utilisé toutes les classes disponibles dans la bibliothèque SD: il en existe d'autres pour, par exemple, faire la liste des fichiers d'un répertoire, effacer un fichier, etc. La liste et la description de toutes les classes peut être consultée sur le site officiel arduino.



Mise à l'essai



Au départ, la carte SD était vide.


J'ai appuyé deux fois sur le bouton "écrire", puis une fois sur le bouton "lire". Le moniteur série m'indique le contenu du fichier (2 lignes de texte). J'appuie encore deux autres fois sur le bouton "écrire", et une fois sur le bouton lire: le moniteur série me montre les 4 lignes de texte maintenant enregistrées dans le fichier.



La carte SD contient maintenant un fichier intitulé "ARCHIVES.TXT dans lequel 4 lignes de texte ont été enregistrées.



Yves Pelletier   (TwitterFacebook)

samedi 2 février 2019

Module RFID-RC522 et ESP8266 / ESP32


N.B. Cet article a été mis à jour le 28 juillet 2019 afin d'ajouter les informations concernant l'ESP32.

Aujourd'hui, notre mission consistera à créer, au moyen d'un module RC522 et d'une carte ESP8266 ou ESP32, un système qui affichera dans une page web les 10 plus récentes détections de tags RFID.

Les informations présentées sur la page web seront, pour chaque détection: la date et l'heure de l'événement, et le numéro d'identification (UID) du tag.

Pour le développement de ce petit projet, j'ai utilisé ma carte Wemos D1, qui est rapidement devenue mon outil préféré pour le prototypage impliquant l'ESP8266. Bien entendu, vous pourrez réaliser le projet avec n'importe quel module ESP8266 (sauf l'ESP-01, qui comporte trop peu de broches GPIO).

Il est facile de se procurer en ligne un module RFID-RC522. Ils sont généralement accompagnés de deux tags de formats différents: une carte de plastique et un petit porte-clés.

Chaque tag RFID possède son propre numéro d'identification. Lorsque vous approchez le tag du module RC522, celui-ci détecte la présence du tag et capte son numéro d'identification.

Pour des projets RFID n'impliquant pas de communication Wi-Fi, vous pouvez consulter mes articles sur l'utilisation d'un détecteur RC522 avec un Arduino, un Raspberry Pi (python), un STM32 Nucleo (mbed) ou un MSP430 Launchpad (Energia).

Installation de la bibliothèque MFRC522

J'ai utilisé la bibliothèque MFRC522 de Miguel Balboa, qui est pleinement compatible avec l'ESP8266.

Connexions

Puisque le module RC522 utilise le protocole SPI, il est connecté à l'ESP8266 de la façon suivante:
  • SDA du RC522 --- GPIO4 de l'ESP8266 ou de l'ESP32
  • SCK du RC522 --- GPIO14 de l'ESP8266 ou GPIO18 de l'ESP32
  • MOSI du RC522 --- GPIO13 de l'ESP8266 ou GPIO23 de l'ESP32
  • MISO du RC522 -- GPIO12 de l'ESP8266 ou GPIO19 de l'ESP32
  • IRQ du RC522 -- Pas connectée
  • GND du RC522 -- GND
  • RST du RC522 -- GPIO 5 de l'ESP8266 ou de l'ESP32
  • 3.3 V du RC522 -- 3.3 V
Le schéma ci-dessous montre ces connexions sur une carte Wemos D1.


Et voici un schéma des connexions sur une carte ESP32:



Vérification du bon fonctionnement du module

Avant d'aborder un programme plus élaboré, ce n'est pas une mauvaise idée d'utiliser un programme minimaliste qui nous permettra de vérifier rapidement le fonctionnement correct de notre module RC522.

Le sketch ci-dessous affiche dans le moniteur série l'UID (numéro d'identification) de chaque tag détecté. Il s'agit du même sketch que j'avais déjà utilisé pour une carte Arduino, la seule différence étant le numéro des broches assignées aux broches RST et SDA.




Un sketch plus élaboré

Pour terminer, voici un sketch qui exploite beaucoup mieux les possibilités de l'ESP8266: il permet de consulter une page web qui affiche les 10 plus récents scans d'un tag RFID (une fois ouverte, cette page web se met à jour automatiquement toutes les 10 secondes).



Lors du démarrage du programme, l'adresse IP qui permet d'accéder à la page web est affichée dans le moniteur série.

Chaque fois qu'un tag RFID est scanné, l'ESP8266 mémorise son numéro d'identification (UID). Il communique également avec un serveur NTP afin de connaître l'heure exacte. 



Yves Pelletier   (TwitterFacebook)