mercredi 30 janvier 2019

PCF8591 et Raspberry Pi

Nous allons voir aujourd'hui comment ajouter une sortie analogique et quatre entrées analogiques au Rasbperry Pi grâce à un module PCF8591 (qui est à la fois un convertisseur analogique-numérique et un convertisseur numérique-analogique). Nous programmerons en langage Python.


Entrée analogique? Sortie Analogique?

Les broches GPIO du Raspberry Pi sont des broches numériques. Lorsqu'elles sont configurées en sortie, elles ne peuvent prendre que deux états différents: 0 V ou 3,3 V.  De même, lorsqu'elles sont configurées en entrée, elles ne peuvent que distinguer deux états différents: 0 V ou 3,3 V.

Une sortie analogique peut prendre n'importe quelle valeur située entre 0 V et 3,3 V. Et une entrée analogique peut distinguer n'importe quelle valeur située entre 0 V et 3,3 V.  Par exemple, une entrée analogique pourra faire la distinction entre une tension de 1 V et une tension de 1,2 V.

Petit bémol, cependant: quand je dis "n'importe quelle valeur", j'exagère un peu. Le PCF8591 est un convertisseur à 8 bits, ce qui signifie que la tension peut prendre 255 valeurs différentes échelonnées entre 0 et 3,3 V.

Description du module

Il est possible d'utiliser un simple circuit intégré PCF8591, mais j'ai plutôt utilisé un module qui comprend, en plus, un petit potentiomètre, une photorésistance et une thermistance (il n'est pas obligatoire d'utiliser ces trois composants: il est facile de les désactiver en retirant les jumpers qui les relient aux entrées du PCF8591).


Les 4 connecteurs situés du côté gauche du module servent à l'alimentation du module (VCC et GND) et à la communication i2c avec le microcontrôleur (SDA e SCL).

Du côté droit, AOUT est la sortie analogique, que nous pouvons régler à n'importe quelle valeur située entre 0 et 3,3 V.  AIN0, AIN1, AIN2 et AIN3 sont les 4 entrées analogiques qui nous permettent de mesurer la valeur d'une tension se situant entre 0 et 3,3 V.

Le potentiomètre est relié à la broche INPUT0, la photorésistance est reliée à la broche INPUT1, et la thermistance est reliée à la broche INPUT2.  Lorsque vous achetez le module, des jumpers acheminent le signal du potentiomètre à l'entrée AIN0, le signal de la photorésistance à l'entrée AIN1 et le signal de  la thermistance à l'entrée AIN2, mais vous pouvez évidemment retirer ces jumpers et brancher des capteurs analogiques de votre choix aux entrées AIN0, AIN1, AIN2 et AIN3.

Connexions

4 fils conducteurs sont nécessaires pour brancher le module PCF8591 au Rasbperry Pi:

                                             Module PCF8591  ----------    Raspberry Pi
                                                        SDA    ---------------  Broche 3 (GPIO2)
                                                        SCL     --------------   Broche 5 (GPIO3)
                                                        VCC   ---------------   Broche 1 (3,3 V)
                                                        GND   ---------------- Broche 6 (GND)
Préparation du Raspberry Pi pour la communication i2c

Il n'y a pas si longtemps, l'activation de l'i2c sur un Raspberry Pi impliquait la modification manuelle de quelques fichiers de préférence à l'aide d'un éditeur de texte.  Ce n'est heureusement plus le cas de nos jours, le réglage se limitant à ouvrir "Configuration du Rasbperry Pi" dans le menu "Préférences"...


...régler "I2C" à "Activé", et redémarrer le Raspberry Pi.


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

Notez que si vous avez un très ancien Raspberry Pi, vous devrez plutôt inspecter le bus 0 ("sudo i2cdetect -y 0"). Sur mon Banana Pi M2 Berry, c'est plutôt le bus 2 ("sudo i2cdetect -y 2").



Script pour la lecture d'une entrée analogique

Voici un script en Python qui affiche la tension mesurée à l'entrée AIN0 du module PCF8591. Elle est convertie en volts (multipliée par 3,3 et divisée par 255), sinon la valeur affichée serait un entier situé entre 0 et 255 volts. Vous pouvez facilement tester ce script en tournant le potentiomètre du module PCF8591, qui est relié à l'entrée AIN0. Vous pouvez également remplacer AIN0 par AIN1, dans le script, et faire varier la valeur affichée en modifiant la quantité de lumière qui atteint la photorésistance.




Script pour le réglage de la sortie analogique

Ce deuxième script fait varier la tension de la sortie analogique AOUT du module PCF8591.  Cette tension prendra successivement les valeurs 0 V, 0,5 V, 1 V, 1,5 V, etc.

Vous pouvez brancher un voltmètre à la sortie AOUT pour vérifier le résultat.





Yves Pelletier   (TwitterFacebook)

samedi 26 janvier 2019

Écran OLED SH1106 I2C et Arduino

Je me suis récemment procuré un petit écran OLED de 128 X 64 pixels et. bien entendu, je me suis empressé de le faire fonctionner  en le branchant à un Arduino.



OLED vs LCD

OLED est l'acronyme de organic light-emitting diode (diode électroluminescente organique, donc).  Contrairement aux cristaux liquides des écrans LCD, les OLED produisent de la lumière et les écrans basés sur cette technologie ne nécessitent donc pas de rétroéclairage, même lorsque vous les utilisez dans l'obscurité. Les images sont plus contrastées et le temps de réponse est plus court. Par contre, on dit que la durée de vie des écrans OLED est plus courte que celle des LCDs (l'image se dégrade avec le temps).

L'écran

Mon écran a une taille de 1,3 pouce (environ 3,5 cm X 1,8 cm) et une résolution de 128 X 64 pixels. Il est basé sur le contrôleur SH1106 et utilise le protocole I2C. L'image produite est blanche sur fond noir.



Branchements

Puisqu'il s'agit d'I2C, les connexions sont assez prévisibles: sans surprise, l'écran comporte deux broches pour l'alimentation (GND et VCC), et deux broches pour le transfert d'information (SCL et SDA).

Le vendeur a spécifié dans sa description que l'écran peut aussi bien supporter une tension de 5 V qu'une tension de 3,3 V, mais j'ignore à quel point c'est vrai. Le SH1106 n'est pas conçu pour des tension de 5 V, mais le fabricant de l'écran a peut-être ajouté un régulateur de tension quelque part. Pour plus de prudence, j'ai utilisé un module abaisseur de tension bidirectionnel spécifiquement conçu pour la communication I2C dans le genre de celui qui est vendu par Adafruit.  Il s'agit peut-être d'une précaution inutile, mais ça ne peut pas faire de mal.

Tout ça pour dire que que les 4 broches de l'écran OLED sont branchés à l'Arduino Uno de la façon suivante:
  • Broche GND de l'écran à une broche GND de l'Arduino
  • Broche VCC de l'écran à la sortie 3.3 V de l'Arduino
  • Broche SCL de l'écran à la broche A5 de l'Arduino (adaptateur de niveau logique entre les deux)
  • Broche SDA de l'écran à la broche A4 de l'Arduino (adaptateur de niveau logique entre les deux)
(Si vous utilisez un modèle d'Arduino autre que l'Uno,  les broches dédiées à la communication I2C ne sont pas nécessairement A4 et A5.)



Recherche et installation d'une bibliothèque

La bibliothèque U8glib a très bonne réputation parmi les utilisateurs d'écrans OLED.  Cependant, j'ai préféré continuer d'utiliser la bibliothèque GFX d'Adafruit, pour que mes programmes déjà réalisés avec un écran LCD de style Nokia soient plus facilement transposables à mon nouvel écran.  Petit inconvénient: puisqu'Adafruit ne fabrique aucun produit contenant le contrôleur SH1106 (car ils préfèrent le SSD1306), ils n'ont pas créé de bibliothèque spécifique au SH1106.

J'ai donc installé la bibliothèque Adafruit_SH1106 de wonho-maker qui, contrairement à ce que son nom pourrait faire croire, n'est pas une bibliothèque officielle réalisée par Adafruit. Il s'agit plutôt d'une modification, réalisée par un particulier, de la bibliothèque qu'Adafruit a produite pour le SSD1306.  Cette bibliothèque nécessite à son tour la présence de la bibliothèque GFX d'Adafruit (version officielle, cette fois), ce qui représente à mes yeux un énorme avantage: toutes les routines que j'ai utilisées sur mon écran LCD Nokia continueront de fonctionner sur mon écran OLED.

Sketch 1: dessiner des formes, afficher une image bitmap

Commençons par un sketch dont la seule fonction vise à illustrer diverses possibilités de la bibliothèque GFX d'Adafruit: écrire du texte à l'écran...



...dessiner des contours de formes géométriques vides...


...dessiner des formes géométriques pleines...


... contrôler des pixels individuels...


...afficher une image bitmap.


Pour plus de détails, je vous invite à lire l'article qui concerne la première version de ce sketch (réalisé pour un écran LCD Nokia), puisque la majeure partie du programme concerne la bibliothèque GFX plutôt que la bibliothèque SH1106.

L'essentiel de mes modifications (par rapport à ma version initiale conçue pour un écran LCD) a consisté à tenir compte de la nouvelle résolution de l'écran (128 X 64 plutôt que 84 X 48) et de l'inversion des couleurs: par défaut, sur un écran OLED, on dessine en blanc sur fond noir alors que c'était l'inverse sur le LCD.  Il est bien sûr possible de mettre le fond de l'écran blanc pour y dessiner en noir, mais les résultats sont beaucoup moins réussis (présence de traînées grisâtres sur le fond blanc).


Sketch 2: mesure analogique présentée sous forme de jauge rectangulaire

Ce sketch présente à l'écran la tension à l'entrée A0­. La version initiale de ce sketch est décrite de façon plus détaillée ici. Pour en faire l'essai, vous pouvez brancher le curseur d'un potentiomètre à l'entrée A0.




Sketch 3: mesure analogique présentée sous forme de graphique cartésien

Cet autre sketch présente également la tension à l'entrée A0, mais sous forme de graphique cartésien, cette fois.  Voir cet article pour la première version de ce sketch.




Sketch 4: menus de navigation contrôlés par 4 boutons

Finalement, j'ai également adapté le sketch que j'avais écrit pour établir un système de menus contrôlé par 4 boutons poussoir.



L'écran est toujours branché à l'Arduino de la même façon que pour les circuits précédents, mais on ajoute un bouton poussoir à chacune des broches 6, 7, 8 et 9:

À lire aussi

J'ai également utilisé cet écran OLED avec un Raspberry Pi, avec une carte STM32 (Nucleo ou Blue Pill), avec un ESP8266 et avec un ESP32.


Yves Pelletier   (TwitterFacebook)

dimanche 20 janvier 2019

Communication 433 MHz entre deux STM32 Blue Pills

Je continue mon exploration des modules Blue Pill (STM32F103C8) avec une communication radio entre deux modules Blue Pill par l'entremise d'une paire émetteur récepteur 433 MHz. Remarquez que la même procédure vous permettra également d'établir une communication entre une Blue Pill et une carte Arduino.

Matériel

Il s'agit de la paire émetteur/récepteur la plus économique qui soit, facile à trouver sur les sites de vente asiatiques.  L'émetteur, de forme carrée, porte souvent la mention "FS1000A".  Il comporte trois broches: Data, Vcc et GND, ainsi qu'un connecteur permettant d'ajouter une antenne.


Le récepteur, de forme rectangulaire, comporte 4 connecteurs, mais les deux connecteurs du centre sont redondants: Data, Vcc et GND encore une fois. À l'extrémité opposée de la carte, un connecteur permet de souder une antenne.



Donc, deux Blue Pills et une paire émetteur-récepteur, pour un montant total qui ne devrait guère dépasser 5 euros.

Connexions

En principe, ces modules sont conçus pour fonctionner à une tension de 5 V, ce qui n'a rien de problématique si vous utilisez une des nombreuses broches de la Blue Pill qui tolèrent les tensions de 5 V. Cependant, je n'ai jamais eu le moindre problème à les alimenter en 3,3 V donc n'hésitez pas à procéder de cette façon si ça vous convient mieux.

Du côté émetteur les branchements sont les suivants:
  • Broche DATA du module émetteur -- Broche B13 de la Blue Pill
  • Broche VCC du module émetteur -- Broche 5 V de la Blue Pill
  • Broche GND du module émetteur -- Broche GND de la Blue Pill


C'est sensiblement la même chose du côté récepteur:
  • Une des broches DATA du module récepteur  -- Broche B13 de la Blue Pill
  • Broche VCC du module récepteur -- Broche 5 V de la Blue Pill
  • Broche GND du module récepteur -- Broche GND de la Blue Pill


De plus, afin de pouvoir utiliser le moniteur série de l'IDE Arduino pour visualiser les informations reçues par le récepteur, le montage récepteur doit pouvoir communiquer avec l'ordinateur, soit par le connecteur USB de la Blue Pill, soit par l'entremise d'un adaptateur série-USB connecté aux broches A9 et A10.


Installation de la bibliothèque

La compatibilité des bibliothèques est un irritant fréquent lorsque vous utilisez l'IDE Arduino pour programmer autre chose qu'une carte Arduino. Par exemple, la bibliothèque VirtualWire, qui aurait fait parfaitement l'affaire pour une communication entre deux cartes  Arduino Uno, ne fonctionne pas pour la Blue Pill (erreur de compilation). En principe, on devrait pouvoir utiliser RadioHead mais mes essais se sont révélés infructueux.

J'ai donc utilisé une version spéciale de la bibliothèque Manchester, que j'avais déjà utilisée pour l'ATTiny85, que quelqu'un a modifiée pour la rendre compatible avec la Blue Pill (trouvée dans cette discussion du forum STM32Duino). Notez que cette bibliothèque est également compatible avec Arduino, ATTiny et ESP8266, ce qui permet d'envisager plusieurs combinaisons intéressantes.

De plus, vous devez avoir installé dans l'IDE Arduino les fichiers nécessaires à la programmation de la Blue Pill.

Les sketches

La paire de sketches que je vous propose ici sont très similaires aux exemples "ManchesterTX_Basic" et "ManchesterRX_Basic" qui sont livrés avec la bibliothèque.

Chaque seconde, l'émetteur envoie un message (il s'agit d'un nombre entier qui augmente d'une unité à chaque transmission). Chaque fois qu'un message est émis, la LED intégrée de la Blue Pill change d'état (à quelques reprises, le non-clignotement de cette LED m'a permis de constater que j'avais oublié de replacer le jumper BOOT0 dans la position qui permet le démarrage automatique du programme).

Le transmetteur surveille l'arrivée d'un éventuel message. Lorsqu'il en reçoit un, il le retransmet par communication série (pour qu'on puisse le voir dans le moniteur série) et il change l'état de la LED intégrée de la Blue Pill.

Vous pouvez ainsi vérifier si tous les messages émis sont captés (à partir d'une certaine distance, vous en perdrez une certaine proportion).



Si vous désirez utiliser un des sketches pour une carte Arduino plutôt qu'une Blue Pill, les deux seules modifications à effectuer sont le numéro de la broche reliée au module émetteur ou récepteur, et le numéro de la broche reliée à la LED (13).

Sketch de l'émetteur:

Sketch du récepteur:



À lire aussi

Ailleurs dans ce blog, la même paire émetteur-récepteur a été utilisée afin d'établir une communication entre deux cartes Arduino,  entre un Raspberry Pi et un Arduino et entre  un ATTiny85 et un Arduino. Les modules nRF24L01 constituent aussi une option intéressante pour établir une communication sans fil entre deux microcontrôleurs.

Yves Pelletier   (TwitterFacebook)

jeudi 17 janvier 2019

PCF8591 et ESP8266 (ou Arduino)

Le circuit intégré PCF8591 combine un convertisseur analogique-numérique à 4 canaux, ainsi qu'un convertisseur numérique-analogique (1 canal). Il peut donc servir à ajouter 4 entrées analogiques et une sortie analogique au microcontrôleur de votre choix.

Le présent billet vous guidera dans l'utilisation d'un module PCF8591, que ce soit avec une carte Arduino ou un ESP8266. À mon avis, le PCF8591 vous sera surtout utile avec un ESP8266 (qui, dans le meilleur des cas, ne comporte qu'une seule entrée analogique limitée à une tension maximale de 1 V).

Pour mes tests, j'ai utilisé un module acheté sur eBay: en plus de comporter un circuit intégré PCF8591, le module est également muni d'un petit potentiomètre, d'une photorésistance et d'une thermistance, qui peuvent être utilisés ou non, selon nos besoins.


Les 4 connecteurs situés du côté gauche du module (SDA, SCL, VCC et GND) servent à l'alimentation du module et la communication i2c avec le microcontrôleur.

Du côté droit, AOUT est la sortie analogique, qui peut prendre n'importe quelle valeur située entre 0 et 5 V (si le module est alimenté avec 5 V) ou entre 0 et 3,3 V (si le module est alimenté avec 3,3 V).  AIN0, AIN1, AIN2 et AIN3 sont les 4 entrées analogiques, qui nous permettent de mesurer la valeur d'une tension se situant entre 0 et 5 V (le le module est alimenté avec 5 V) ou entre 0 et 3,3 V (si le module est alimenté avec 3,3 V).

Le potentiomètre est relié avec la broche INPUT0, la photorésistance est reliée à la broche INPUT1, et la thermistance est reliée à la broche INPUT2.  Lorsque vous achetez le module, des jumpers acheminent le signal du potentiomètre à l'entrée AIN0, le signal de la photorésistance à l'entrée AIN1 et le signal de  la thermistance à l'entrée AIN2, mais vous pouvez évidemment retirer ces jumpers et brancher des capteurs analogiques de votre choix aux entrées AIN0, AIN1, AIN2 et AIN3.

Connexions

On branche le module PCF8591 à une carte Arduino Uno de la façon suivante:

Module PCF8591    ---    Arduino Uno
   SDA  ----------------------  A4
   SCL  ----------------------  A5
   VCC  ---------------------  5 V
   GND  --------------------  GND



Pour brancher le module PCF8591 à un ESP8266, les connexions seront plutôt:

Module PCF8591    ---    Module ESP826
   SDA  ----------------------  GPIO4
   SCL  ----------------------  GPIO5
  VCC  -----------------------  3,3 V
  GND  ----------------------  GND






Installation de la bibliothèque PCF8591

Plutôt que d'étudier la fiche technique du PCF8591, j'ai installé la bibliothèque PCF8591 conçue par xreef. Comme vous pourrez le constater dans les deux sketches ci-dessous, cette bibliothèque rend la programmation très facile.

Sketch pour lire une entrée analogique

La valeur de n'importe quelle des 4 entrées analogiques sera mesurée grâce à la fonction analogRead(). Attention: le PCF8591 est un convertisseur 8 bits, et la valeur obtenue varie donc entre 0 et 254. Par comparaison, les entrées A0 à A5 de l'Arduino sont à 10 bits, pour une résolution 4 fois plus grande (0 à 1023).

Le sketch ci-dessous affiche dans le moniteur série la valeur mesurée à l'entrée AIN0. Si le jumper est en place sur le module, vous pouvez tester le sketch en tournant le potentiomètre du module au moyen d'un tournevis: la valeur affichée dans le moniteur série variera entre 0 et 255 selon la position du potentiomètre.  Pour lire les 3 autres entrées, il s'agit évidemment de remplacer AIN0 par AIN1, AIN2 ou AIN3.





Sketch pour contrôler la sortie analogique

Le sketch ci-dessous contrôle la tension de la sortie AOUT du module, au moyen de la fonction analogWrite(). Si le module est alimenté avec une tension de 5 V, la tension de AOUT devrait être nulle si vous écrivez "analogWrite(0)" , 5 volts si vous écrivez "analogWrite(255)", et une valeur se situant entre 0 et 5 V pour un argument se situant enter 0 et 255.  Toutefois, sur mon module, "analogWrite(255)" ne donne qu'une tension de sortie de 4,13 V, soit à peu près la même valeur que si j'écris "analogWrite(210)"! J'ignore s'il s'agit d'un défaut exclusif au module que j'ai utilisé, où s'il s'agit d'un problème plus généralisé.

Pour cette raison, le sketch ci-dessous se limite à une valeur maximale de 200 comme argument de la fonction analogWrite(). Il permet de faire varier la tension de sortie de façon sinusoïdale (ou en dents de scie si vous utilisez plutôt la ligne qui a été commentée).

Voici le résultat affiché à l'écran d'un oscilloscope branché à la sortie AOUT:









Yves Pelletier   (TwitterFacebook)

mardi 15 janvier 2019

Afficheur LCD Nokia 5110 et Raspberry Pi

Il est parfois souhaitable que le Raspberry Pi affiche quelques informations sur un écran, mais sans qu'il soit nécessaire de recourir à un écran HDMI plus coûteux et plus encombrant. Dans une telle situation, l'utilisation d'un petit écran LCD de type Nokia 5110 peut s'avérer une solution intéressante.

Le présent article décrit donc l'affichage de texte et d'éléments graphiques sur un afficheur Nokia 5110, grâce à un script en Python. Les tests ont été réalisés sur un Raspberry Pi 2.

Module "Nokia 5110"

"Nokia 5110" est, en fait, le nom du téléphone qui utilisait ce modèle d'écran à la fin des années 1990. ll s'agit d'un afficheur à cristaux liquides (LCD) monochrome associé à un contrôleur Philips PCD8544, dont la résolution est de 84 X 48 pixels (sa taille est de 3,5 cm par 2,5 cm environ).

Pour faciliter les branchements avec le Rapsberry Pi ou 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 également proposés chez les commerçants 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.  Peu importe le modèle que vous choisissez, vous devrez probablement souder vous-même la barrette de 8 connecteurs.


Branchements de l'afficheur au Raspberry Pi

Voici la description des 8 connections à effectuer entre l'afficheur LCD et le Raspberry Pi. Notez que les symboles indiqués sur l'afficheur ne sont pas toujours identiques selon que vous utilisez le modèle Sparkfun ou le modèle Adafruit, j'ai donc essayé autant que possible d'écrire toutes les possibilités.
  • Broche Vcc de l'écran  --- Broche 17 (sortie 3,3 V) du Raspberry Pi
  • Broche GND de l'écran --- Broche 20 (GND) du Raspberry Pi
  • Broche SCE ou CS de l'écran --- Broche 24 (GPIO 8) du Raspberry Pi
  • Broche RST de l'écran --- Broche 18 (GPIO 24) du Raspberry Pi
  • Broche D/C de l'écran --- Broche 16 (GPIO 23) du Raspberry Pi
  • Broche DN (MOSI) ou DIN de l'écran --- Broche 19 (GPIO 10) du Raspberry Pi
  • Broche SCLK ou CLK de l'écran --- Broche 23 (GPIO 11) du Raspberry Pi
  • Je n'ai pas branché la broche LED de l'écran (je n'avais pas besoin du rétroéclairage).


Notez que le schéma ci-dessus est correct pour la version "Sparkfun" de l'écran. Je crois que les broches ne sont pas dans le même ordre sur la version "Adafruit" (référez-vous alors à la description plutôt qu'au schéma).

Préparation du Raspberry Pi

Si ce n'est pas déjà fait, il est important que les broches dédiées à la communication SPI soient activées.  Pour ce faire, on ouvre "Configuration du Raspberry Pi" dans le menu "Préférences" de Raspbian.


Dans l'onglet, on coche "Activé" sur la ligne "SPI".



De plus, nous avons besoin d'installer deux bibliothèques pour Python.

Pour faire l'installation de la "Python Imaging Library", on peut écrire cette ligne dans le terminal:

sudo apt-get install python-imaging



Pour l'installation de la bibliothèque Nokia d'Adafruit, ce sont 4 lignes qui devront être écrites dans le terminal:

Tout d'abord, on installe "git", au cas où il ne le serait pas déjà (il est probablement déjà installé).

sudo apt-get install git


On va chercher la bibliothèque sur GitHub:

git clone https://github.com/adafruit/Adafruit_Nokia_LCD.git


Il reste à exécuter un script d'installation qui se trouve à l'intérieur du répertoire que nous venons d'installer. On entre donc à l'intérieur de ce répertoire:

cd Adafruit_Nokia_LCD


Et on exécute le script d'installation:

sudo python setup.py install


Votre petit écran devrait maintenant pouvoir être piloté au moyen d'un script en Python. Une façon rapide et efficace de vérifier que tout fonctionne correctement consiste à explorer les 3 fichiers d'exemple qui se trouvent  à l'intérieur du répertoire Adafruit_Nokia_LCD/examples:
  • shapes.py affiche une image statique constituée d'un cercle, un carré, un triangle, un X et l'inévitable expression "Hello World!"

  • image.py affiche le contenu du fichier "happycat_lcd.ppm" (un chat)

  • animate.py montre une phrase qui bouge en formant une forme sinusoïdale.


Exemple de script

Je vous propose ici un quatrième exemple de script: après une courte animation d'ouverture (qui consiste en une pointe de tarte dont l'angle d'ouverture augmente jusqu'à devenir un cercle complet), l'écran affiche la date, l'heure et l'adresse IP utilisée par votre Raspberry Pi.  Remarquez qu'une fois le script terminé, l'écran continue d'afficher la dernière image.

Pour faciliter le débogage, le script affiche également dans le terminal une description de ce qu'il est en train d'afficher dans le LCD.


Animation d'ouverture:


Adresse IP:


Date et heure:


Pub narcissique:



Pour ceux qui préfèrent une vidéo:




Utilisation de la Python Imaging Library, en bref

Pour terminer, voici quelques informations sur la façon d'écrire et dessiner à l'écran grâce à la PIL (Python Imaging Library). Loin de moi l'idée de vous donner un cours complet sur le sujet. Vous trouverez plus d'informations ailleurs sur le web, par exemple ici.

La position de chaque pixel sur l'écran 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.

Pour écrire du texte à l'écran, on utilise une commande de ce genre:

draw.text((5,10), "Bonjour", font=font)

Comme résultat, le mot "Bonjour" sera affiché à l'écran. Son point de départ sera le pixel situé aux coordonnées x = 5, y = 10.

Pour dessiner un rectangle, on peut utiliser:

draw.rectangle((5,10,70,22), outline=0, fill=255)

Dans ce cas, le coin supérieur gauche du rectangle sera le pixel situé à x =5 et y = 10. Il sera large de 70 pixels et haut de 22 pixels. Son contour sera noir (outline = 0) et il sera rempli de blanc (fill = 255).

On peut également tracer des points (pixels individuels), des lignes droites, des ellipses, des polygones, etc.  De plus, tel qu'illustré dans l'exemple "image.py", il est possible d'afficher une image enregistrée dans un fichier.

Lire aussi

Grâce à un script en python sur Raspberry Pi, vous pouvez également contrôler un écran couleur SPI ST7735, un écran OLED SH1106 ou un afficheur 16 X 2.

Le même écran Nokia 5110 peut aussi être contrôlé au moyen d'un Arduino, d'un ESP32/ESP8266 ou d'un MSP430 Launchpad.

Yves Pelletier   (TwitterFacebook)

vendredi 11 janvier 2019

Utiliser l'horloge temps réel de la Blue Pill

Un avantage intéressant de la Blue Pill, c'est qu'elle comporte une horloge temps réel (RTC ou Real time clock) intégrée (le petit truc noir encerclé sur la photo ci-contre est un résonateur 32,768 kHz). Votre Blue Pill peut donc connaître la date et l'heure sans qu'il soit nécessaire de la relier à un module RTC externe.

La bibliothèque RTClock, qui fait partie des fichiers que nous avons installés dans le dossier "hardware" lors de notre première utilisation de la Blue Pill avec l'IDE Arduino, nous facilitera grandement la tâche lors de l'utilisation de l'horloge.   Grâce à cette bibliothèque, il est facile de savoir qu'elle heure il est, quelle est la date, s'agit-il d'un lundi ou d'un vendredi, etc.

Le sketch fourni à la fin de ce billet utilise l'horloge temps réel de la Blue Pill pour afficher la date et l'heure dans le moniteur série (réglé à 9600 bauds).

Lorsque vous démarrez le programme, votre Blue Pill prétend que vous êtes en pleine célébration du jour de l'an 1970! Pas d'inquiétude: la bibliothèque RTClock utilise l'heure Unix, c'est à dire le nombre de secondes écoulées depuis le 1er janvier 1970. Puisque l'horloge vient d'être initialisée, elle indique le nombre de secondes écoulées depuis sa mise en marche et non le nombre de secondes écoulées depuis le 1er janvier 1970.



Pour remédier à la situation, le sketch contient une routine (receptionMessage()) qui permet à l'utilisateur de régler l'heure au moyen du moniteur série: il s'agit d'y entrer l'heure Unix et de cliquer sur le bouton "Envoyer".


L'horloge indique maintenant l'heure actuelle.



Pour connaître l'heure Unix actuelle (qui est, rappelons-le, le nombre de secondes écoulées depuis le 1er janvier 1970), vous pouvez utiliser un outil en ligne comme par exemple le site Epoch Converter.
Si l'heure affichée dans le moniteur série ne correspond toujours pas à votre heure locale, vérifiez si la variable fuseauHoraire, déclarée au début du sketch correspond bien au fuseau horaire dans lequel vous vous trouvez­. Il s'agit du nombre d'heures de décalage par rapport à l'heure GMT.

La routine afficheHeure() affiche la date et l'heure dans le moniteur série. Elle peut sembler un peu longue à première vue, mais une grande partie du code concerne des détails d'ajustement d'affichage (comme, par exemple, ajouter un zéro devant le nombre de secondes si la valeur est plus petite que 10).  Ce qu'il est important de savoir, c'est que:
  • day() retourne le jour (si nous sommes le 17 mars, day() vaut 17).
  • month() retourne le mois (1 pour janvier, 2 pour février, etc.)
  • year() retourne le nombre d'années écoulées depuis 1970.
  • weekday() retourne le nombre de la semaine (0 pour lundi, 1 pour mardi, etc.)
  • hour() retourne l'heure
  • minute() contient le nombre de minutes
  • second() contient le nombre de secondes



Bien entendu, vous pouvez modifier le sketch pour rendre l'horloge complètement indépendante de l'ordinateur, en affichant l'heure sur un écran LCD, et en réglant l'heure au moyen de boutons poussoirs, par exemple.

Yves Pelletier   (TwitterFacebook)