dimanche 21 octobre 2018

Opérations bit à bit (Arduino)

Si la lecture d'une expression du genre "byte var2 = var1 & ~(1 << 3); " vous laisse dubitatif, ce billet est pour vous: nous allons tenter de démystifier les opérations bit à bit (bitwise operations, en anglais).

Des bits?

Toutes les variables que vous utilisez dans un programme sont constituées d'un certain nombre de bits, et chacun de ces bits peut prendre deux valeurs possibles: 0 ou 1. La notation binaire permet de montrer de façon explicite la valeur de chacun de ces 8 bits.

Par exemple, dans la ligne ci-dessous, on créé une variable de type byte nommée "mon_octet" dont tous les bits on la valeur 1:

byte mon_octet = 0b11111111;

(Notez que "0b" au début de l'expression sert à indiquer qu'il s'agit d'un nombre en binaire. On aurait obtenu le même résultat en utilisant "255" (notation décimale) ou "0xFF" (notation hexadécimale).

Une variable de type int comporte 16 bits! Donc, quand vous écrivez en notation décimale quelque chose comme...

int mon_entier = 4807;

...la valeur des 16 bits sera réglée de la même façon que si vous aviez écrit:

int mon_entier = 0b0001001011000111;

La particularité des opérations bit à bit (ou bitwise), c'est qu'elles s'appliquent à chaque bit individuellement.

À quoi ça sert?

Pourquoi quelqu'un aurait-il l'idée saugrenue de considérer individuellement chaque bit d'une variable? Essentiellement, parce qu'il s'agit de la façon la plus compacte d'emmagasiner et de transmettre de l'information dans des circuits numériques.

Par exemple, le microcontrôleur Atmega 328 qui constitue le cerveau de la carte Arduino Uno comporte des registres qui permettent de lire ou de modifier l'état logique de ses broches.  Le registre DDRD, par exemple, comporte 8 bits associés aux broches 0 à 7 de l'Arduino.  Si DDRD a la valeur 0b11110000, ça signifie que les broches 0 à 3 sont réglées en entrée, alors que les broches 4 à 7 sont réglées en sorties.  Lorsque vous utilisez la fonction pinMode() du langage Arduino, vous modifiez indirectement la valeur de ce registre, mais il est aussi possible de modifier directement le registre au moyen des opérations bit à bit.

De nombreux capteurs numériques qui communiquent avec l'Arduino comportent aussi des registres à 8 bits qu'il faut lire et/ou modifier lors de leur utilisation. Les opérations bit à bit nécessaires sont souvent effectuées en arrière-plan par des bibliothèques.

Vous pourriez vous mêmes choisir d'utiliser des opérations bit à bit à l'intérieur des scripts que vous écrivez, afin d'économiser la mémoire.  En effet, l'information équivalent à 8 variables booléennes peut être emmagasinée dans une seule variable de type "byte" (1 octet), alors que si vous utilisez 8 variables distinctes de type "bool" (qui ont une taille d'un octet chacun), vous utiliserez 8 fois plus de mémoire pour emmagasiner la même quantité d'information.  (C'est encore pire si vous emmagasinez l'information dans 8 variables distinctes de type "int": vous accaparez alors 16 octet, soit 16 fois plus que nécessaire!)

Voyons maintenant chaque opérateur bit à bit.

L'opérateur NON (NOT), symbolisé par ~, a pour effet d'inverser chaque bit: les bits qui valaient 1 deviennent 0, et ceux qui valaient 0 deviennent 1.

Dans l'exemple illustré ci-dessous, le bit numéro 7 de l'octet A vaut 1, donc le bit numéro 7 de l'octet ~A vaut 0. Le bit numéro 6 de l'octet A vaut 0, donc le bit numéro 6 de l'octet ~A vaut 1.  Et ainsi de suite.


L'opérateur ET (AND),dont le symbole est &, donne 1 si les deux bits valent 1. Sinon, il donne zéro.

Dans l'exemple illustré ci-dessous, le bit numéro 7 de l'octet A vaut 1 et le bit numéro 7 de l'octet B vaut zéro, donc le bit numéro 7 de l'expression "A & B" vaut 0.

Par contre, le bit numéro 5 de "A & B" vaut 1, puisque le bit numéro 5 de A et le bit numéro 5 de B valent 1 tous les deux.


L'opérateur OU (OR), dont le symbole est |, donne 0 uniquement si les deux bits valent 0.  Sinon, l'opération donne 1.


L'opérateur OU Exclusif (XOR), dont le symbole est ^, donne 1 à la condition que les deux bits soient de valeurs différentes. Si les deux bits ont la même valeur, l'opération donne 0.



L'opérateur décalage vers la gauche (left shift), dont le symbole est <<, déplace tous les bits vers la gauche, du nombre de positions spécifié.

Dans l'exemple ci-dessous, l'opération A << 1 déplace tous les bits d'une position vers la gauche.  Ainsi, le bit numéro 7 de A << 1 a la même valeur que le bit numéro 6 de A, le bit numéro 6 de A << 1 a la même valeur que le bit numéro 5 de A, etc.

L'exemple montre également l'opération A << 3, qui décale tous les bits de 3 positions vers la gauche. Le bit numéro 7 de A << 3 a donc la même valeur que le bit numéro 4 de A, le bit numéro 6 de A << 3 a la même valeur que le bit numéro 3 de A, etc.


L'opérateur décalage vers la droite (right shift), dont le symbole est >>, déplace tous les bits vers la droite, du nombre de positions spécifié.

Comme on peut le constater dans l'exemple ci-dessous, tous les bits de A >> 1 sont décalés d'une position vers la droite par rapport à ceux de A. Le bit numéro 6 de A >> 1 a donc la valeur du bit numéro 7 de A, le bit numéro 5 de A >> 1 a la valeur du bit numéro 6 de A, etc.

Quant aux bits de A >> 3, ils ont été décalés vers la droite de trois positions par rapport aux bits de l'octet A.


Quelques exemples concrets:

Nous allons maintenant mentionner quelques applications fréquentes qui nécessitent une combinaison de plusieurs opérateurs bit à bit: la lecture d'un bit, l'assignation de la valeur 1 à un bit, l'assignation de la valeur 0 à un bit et l'inversion de la valeur d'un bit.

Toutes ces opérations impliquent l'usage d'un masque, c'est à dire un octet dont la valeur permet de laisser intacte la valeur des bits qu'on ne désire pas modifier.

Lecture d'un bit en particulier

Pour lire la valeur d'un bit en particulier, on utilise l'opérateur & avec un masque dont tous les bits sont nuls, sauf celui qui occupe la position pour laquelle on souhaite connaître la valeur.

L'exemple ci-dessous montre l'opération A & (1 << 2), qui permet de connaître la valeur du bit numéro 2 de A.

1 << 2 est le masque.  Il s'agit du nombre 1 (donc 00000001) qui a subit un décalage de deux positions vers la gauche (ce qui donne 00000100). 

Tous les bits de A & (1 << 2) seront donc nuls, sauf le bit numéro 2, qui vaudra 1 à la condition que le bit numéro 2 de A soit 1 lui aussi:


Par contre, si la valeur du bit testé est nulle, tous les bits de l'opération seront nuls.

Par exemple, dans l'exemple ci-dessous, nous cherchons la valeur du bit numéro 4 de A grâce à l'opération A & (1 << 4).

Notre masque est maintenant 1 << 4, qui correspond à 00000001 ayant subit un décalage vers la gauche de 4 positions (donc 00010000). Ce masque garantit que seule la valeur du bit numéro 4 de A aura une influence sur le résultat. Mais ce bit est nul, et tous les bits de l'opération A & (1 << 4) sont donc nuls.


Bref: si le bit n de A vaut zéro, l'opération A & (1 << n) retourne la valeur zéro, alors que si le bit n de A vaut 1, l'opération A & (1 << n) retourne autre chose que zéro.  Il ne reste plus qu'à tester si le résultat est nul ou non pour en déduire la valeur du bit n.

Assignation de la valeur 1 à un bit en particulier

Pour que le bit de position n de l'octet A prenne la valeur 1 et que tous les autres bits conservent leur valeur initiale, on utilise l'opération A | (1 << n).

Dans l'exemple ci-dessous, on désire que le bit numéro 4 de A devienne 1. On utilise donc le masque 1 << 4, qui vaut 00010000, combiné avec l'opérateur "ou".


En général, on voudra que ce résultat remplace la valeur initiale de A. On pourra donc écrire:

A = A | (1 << 4);

...ou encore une forme plus compacte:

A |= 1 << 4;

Assignation de la valeur 0 à un bit en particulier

Pour que le bit de position n de l'octet A prenne la valeur 0 et que tous les autres bits conservent leur valeur initiale, on utilise l'opération A &  ~(1 << n).

Cette fois, nous utilisons l'opération NON (~) afin d'obtenir un masque dont tous les bits valent 1, sauf celui qui occupe la même position que le bit que nous désirons modifier.  Dans l'exemple ci-dessous, nous assignons la valeur 0 au bit numéro 5 seulement. 1 << 5 aurait donné 00100000, mais ~(1 << 5) donne plutôt 11011111.  On peut voir que le résultat de l'opération A & ~(1 << 5) donne la même chose que A, sauf que le bit numéro 5 est devenu nul.


Ici encore, si vous désirez que le résultat remplace l'ancienne valeur de A, il faudra ajouter une assignation:

A = A & ~ ( 1 << 5);

... ou encore:

A &=  ~ ( 1 << 5);

Inversion d'un bit en particulier

Voyons maintenant comment inverser ("toggle") la valeur d'un seul bit tout en laissant les autres bits inchangés.  Cette fois, nous utilisons le "ou exclusif".

Pour que le bit de position n de l'octet A soit inversée et que tous les autres bits conservent leur valeur initiale, on utilise l'opération A ^ (1 << n).

Voyez l'exemple ci-dessous: le résultat de l'opération A ^ (1 << 7) est identique à A, sauf que le bit numéro 7, qui était 1, est maintenant 0.

Dans l'exemple ci-dessous, nous inversons le bit numéro 6, qui passe de 0 à 1:


Pour que la variable initiale soit modifiée:

A = A ^ (1 << 6);

... ou la version plus compacte:

A ^= (1 << 6);

Terminus, tout le monde descend!

Je n'irai pas plus loin que ces quelques exemples qui, j'espère, vous auront aidé à comprendre le principe des opérations bit à bit. Il existe bien entendu d'autres applications possibles, comme par exemple assigner simultanément une valeur à plusieurs bits différents tout en n'affectant pas la valeur de plusieurs autres bits. Il y a aussi la possibilité d'effectuer certaines opérations mathématiques avec plus de rapidité (le décalage d'une position vers la gauche correspond à une multiplication par deux, alors que le décalage d'une position vers la droite correspond à une division par deux).

Un sketch de démonstration

Pour finir, je vous propose un sketch Arduino qui illustre toutes les opérations présentées dans cet article.  Au départ, deux octets sont générés au hasard et le résultat des différentes opérations s'affiche dans le moniteur série.  La totalité du programme se trouve à l'intérieur de setup, vous devez donc appuyer sur le bouton reset de votre carte Arduino pour générer une nouvelle paire d'octets.



Yves Pelletier   (TwitterFacebook)

samedi 20 octobre 2018

Mesurer une température avec MPLAB Xpress Evaluation Board

Une caractéristique intéressante du MPLAB Xpress Evaluation Board que j'avais négligée jusqu'à maintenant, c'est qu'il comporte un capteur de température EMC1001.  Sur la carte, il s'agit d'un tout petit circuit intégré comportant 6 broches, identifié par la mention "U5", et situé un peu plus haut que l'interrupteur "S2". Ce capteur communique en I2C, et permet de mesurer une température située entre -25°C et 125°C avec une résolution de 0,25°C

Cette activité consiste à afficher la température à l'écran d'un ordinateur, dans un logiciel de communication série (j'ai utilisé comme référence principale ce tutoriel conçu par Microchip). Puisque le capteur de température se trouve déjà sur la carte, ce projet ne nécessite rien d'autre qu'un MPLAB Xpress Evaluation Board branché par USB à un ordinateur.

Création du projet dans MPLAB Xpress et réglages dans MCC

Nous commençons par créer un nouveau projet dans MPLAB Xpress.  Si vous êtes pressé, vous pouvez cliquer sur "Microchip Examples", puis sur "PIC16F18855" et ouvrir l'exemple intitulé "Temperature Sensor": félicitations, votre projet est terminé! 😊


Je propose plutôt de créer un nouveau projet autonome que nous construirons nous-mêmes à partir de zéro (Standalone Project).  On vous demandera ensuite de choisir votre modèle de microcontrôleur (c'est le PIC16F18855) et de choisir un titre pour votre projet.


Maintenant, que le nouveau projet est créé dans MPLAB Xpress, nous ouvrons le logiciel MPLAB Xpress Code Configurator qui, lui, est installé localement sur votre ordinateur (si ce n'est pas le cas, vous trouverez plus d'informations concernant l'installation de MCC dans ce précédent billet).

Aucun changement n'est requis dans la partie "System Module" de MCC. Par contre, puisque le capteur de température communique avec le microcontrôleur avec le protocole I2C, nous installons le module "MSSP2" dans la zone "Device Resources" (cliquez deux fois).  MSSP signifie "Master Synchronous Serial Port".


Par défaut, le module MSSP2 est déjà réglé "I2C Master": c'est ce que nous voulons.  Deux changements doivent toutefois être effectués dans ses paramètres: "Slew Rate Control" doit être réglé à "Standard Speed" et "Baud Rate Generator Value" doit être réglé à "0x4".


Puisque nous transmettrons des données par communication série, nous devons aussi installer un module EUSART.


Deux cases supplémentaires doivent être cochées dans les réglage du module EUSART: "Enable Transmit" et "Redirect STDIO to USART".  Par défaut, le baud rate est réglé à 9600, vous pouvez le modifier si vous souhaitez régler votre logiciel de communication série à une vitesse de transmission différente.



Dans la zone des cadenas au bas de la fenêtre, on choisit la broche 0 du port C pour EUSART TX (cette broche est liée à l'USB), la broche 3 du port C pour MSSP2 SDA2, et la broche 4 du port C pour MSSP2 SCL2 (car le capteur de température est branché à ces deux broches).


On clique ensuite sur le bouton "Generate" afin que les fichiers d'en-têtes soient créés et ajoutés au projet dans MPLAB Xpress.


Une fois de retour dans MPLAB Xpress, le script ci-dessous doit être collé dans le fichier main.c.  Pour la gestion de la communication i2c, ce script utilise plusieurs routines qui se trouvent dans le fichier "i2c2.c" qui a été généré par MPLAB Xpress Code Configurator.  Essentiellement, le programme obtient la température en degrés Celsius qui se trouve dans deux registres différents:  TEMP_HI pour la partie entière et TEMP_LO pour la partie fractionnaire (en quarts de degrés).  Cette valeur est ensuite envoyée à l'ordinateur par communication série USB.

On n'oublie pas, évidemment, de compiler le projet et le téléverser dans le microcontrôleur.

Un bug!!!

...sauf que ça ne fonctionne pas!  Ce script ne parvient jamais à sortir de la routine "EMC1001_Read"!

Après avoir soigneusement analysé l'exemple tout fait (et fonctionnel) fourni par Microchip et mon propre projet (qui devrait en principe être identique), j'ai fini par remarquer que le fichier "i2c2.c" généré par MCC avait été légèrement modifié dans l'exemple clé en main: pouvez-vous voir la différence?

Voici la version créée par MCC, qui ne fonctionne pas:



Et voici celle qui fonctionne grâce à une toute petite modification:


Bravo si vous avez détecté le point virgule qui a mystérieusement été ajouté à la fin de la ligne 684!  Ce point virgule a pour effet de désactiver la boucle while: l'instruction "PIR3bits.SSP2IF = true"  ne s'exécute qu'une seule fois plutôt que de façon répétitive jusqu'à ce que la condition soit satisfaite.

Il nous reste donc à effectuer cette modification pour que notre programme fonctionne.  Il faut donc ouvrir le fichier i2c2.c dans MPLAB Xpress...



...et ajouter ce point virgule à la fin de la ligne 684.


On recompile et téléverse à nouveau, et cette fois notre thermomètre est fonctionnel.

Il ne reste plus qu'à utiliser un logiciel de communications série (Tera Term, PuTTy, le moniteur série de l'IDE Arduino, etc.) pour voir le résultat.

Ici, la température augmente progressivement suite à un séjour de quelques minutes au congélateur:


On peut bien sûr ajouter un afficheur LCD pour que le dispositif soit autonome.

Yves Pelletier   (TwitterFacebook)

jeudi 11 octobre 2018

Afficheur à cristaux liquide (LCD) et MPLAB XPress Evaluation Board


Dans ce billet, je vous explique comment j'ai procédé pour piloter un afficheur à cristaux liquides 16 X 2 (2 lignes de 16 caractères) muni du contrôleur Hitachi HD44780 au moyen d'une carte MPLAB Xpress Evaluation Board (cette carte est munie d'un microcontrôleur PIC16F18855).

Connexions de l'afficheur à la carte

Dans un premier temps, il est important de noter que la carte MPLAB Xpress Evaluation Board fonctionne à un niveau logique de 3,3 V, alors que la plupart des afficheurs 16 X 2 sont conçus pour fonctionner à 5 V.

Il existe des afficheurs conçus pour fonctionner à 3,3 V. Si votre afficheur est conçu pour un fonctionnement à 5 V, il est possible qu'il fonctionne malgré tout, mais ce n'est pas certain.

L'afficheur comporte 16 broches, qui sont branchées à la carte de la façon suivante:
  • VSS de l'afficheur : GND de la carte
  • VDD de l'afficheur : 3,3 V de la carte (ou 5 V s'il s'agit d'un afficheur conçu pour 5 V)
  • VO de l'afficheur: curseur d'un potentiomètre qui sert à régler le contraste
  • RS de l'afficheur : RB0 de la carte
  • RW de l'afficheur : RB1 de la carte
  • E de l'afficheur : RB2 de la carte
  • D0 de l'afficheur : RC0 de la carte
  • D1 de l'afficheur : RC1 de la carte
  • D2 de l'afficheur : RC2 de la carte
  • D3 de l'afficheur : RC3 de la carte
  • D4 de l'afficheur : RC4 de la carte
  • D5 de l'afficheur : RC5 de la carte
  • D6 de l'afficheur : RC6 de la carte
  • D7 de l'afficheur : RC7 de la carte
  • A de l'afficheur: 3,3 V de la carte (si un rétroéclairage est souhaité)
  • K de l'afficheur: GND de la carte

Création d'un projet dans MPLAB Xpress

Je suis ensuite allé dans l'IDE en ligne MPLAB Xpress afin de créer un nouveau projet (Standalone Project).  S'il s'agit de votre première utilisation de MPLAB Xpress, vous voudrez peut-être d'abord vous référer à ce précédent article.



Réglages dans MPLAB Xpress Code Configurator

Une fois le projet créé dans MPLAB Xpress, on ouvre le MPLAB Xpress Code Configurator (si MCC n'est pas déjà installé sur votre ordinateur, vous trouverez quelques informations utiles dans ce précédent article).

Vous n'avez pas à modifier quoi que ce soit dans la partie "System Module". Les paramètres par défaut conviennent parfaitement.


Au bas de la fenêtre, cliquez sur les cadenas de façon à définir les broches 0, 1 et 2 du port B et toutes les broches du port C comme sortie (OUTPUT):


Accédez ensuite à la zone "Pin Module" et décochez toutes les cases qui ont été réglées à "Analog" par défaut.



C'est tout! Il ne reste qu'à cliquer sur le bouton "Generate" pour que les fichiers d'en-tête soient automatiquement créés et ajoutés dans notre projet MPLAB Xpress.



Script

Le script ci-dessous peut être collé dans le fichier "main.c" de votre projet dans MPLAB Xpress.

Puisque je n'ai pas utilisé de bibliothèque, on y trouve la routine "initialisation_LCD" qui initialise l'afficheur au démarrage du programme, "envoie_commande" pour envoyer des instructions à l'afficheur, "affiche_caractere" pour afficher des lettres sur l'afficheur, et "gestion_string" qui divise une chaîne de caractères en caractères individuels afin qu'ils soient ensuite affichés.

Vous pourrez probablement laisser ces fonctions telles quelles, et vous contenter d'apporter des modifications à la partie "main", à la fin du programme.  Dans cette partie, j'affiche le mot "ÉLECTRONIQUE" sur la première ligne de l'afficheur. Sur la deuxième ligne, j'affiche "EN AMATEUR", puis un nombre entier qui augmente d'une unité à chaque seconde.



Vous trouverez ici d'autres projets impliquant le MPLAB Xpress Evaluation Board.  Si c'est plutôt l'afficheur à cristaux liquides qui vous intéresse, voyez comment ils peut être utilisé avec d'autres cartes: Arduino, Raspberry Pi, STM32 Nucleo ou MSP430 Launchpad.

Yves Pelletier   (TwitterFacebook)

dimanche 7 octobre 2018

Lecture d'un codeur rotatif avec STM32 Nucleo (mbed)

Dans ce court billet, je vous présente comment j'ai procédé pour lire l'état d'un codeur rotatif en quadrature (rotary encoder) avec une carte STM32 Nucleo programmée avec mbed.

Un codeur rotatif peut être décrit sommairement comme une paire d'interrupteurs qui s'ouvrent et se ferment de façon répétée pendant qu'on tourne un bouton. Les deux interrupteurs changent d'état à des moments légèrement différents, et il est possible d'utiliser cette caractéristique pour déterminer le sens de rotation du bouton  (pour une description plus détaillée du principe de fonctionnement, voir ce précédent billet).

Le codeur rotatif que j'ai utilisé est un module de type "KY-040" qui comporte 5 connecteurs:
  • CLK (clock): premier interrupteur actionné par la rotation du bouton
  • DT (data): deuxième interrupteur actionné par la rotation du bouton
  • SW (switch): interrupteur actionné quand on appuie sur le bouton
  • GND: à relier à la masse
  • +: à relier à 3,3 V

J'ai branché le module à la carte Nucleo de la façon suivante:
  • broche CLK du codeur rotatif: broche D2 du Nucleo
  • broche DT du codeur rotatif: broche D3 du Nucleo
  • broche SW du codeur rotatif: broche D7 du Nucleo
  • broche GND du codeur rotatif: broche GND du Nucleo
  • broche + du codeur rotatif: broche 3V3 du Nucleo
Pour programmer la carte Nucleo au moyen de l'IDE en ligne mbed, j'ai utilisé la bibliothèque RotaryEncoder par Shinchiro Nakamura.


Dans le script ci-dessous, j'utilise le créateur "RotaryEncoder" pour créer un objet nommé "codeur".  Les deux premiers arguments sont les numéros des broches auxquelles le codeur est branché sur la carde (D2 et D3, dans mon cas).  Les 3 arguments suivants indiquent respectivement la valeur minimale, la valeur maximale et la valeur par défaut associées au codeur:

RotaryEncoder codeur(D2, D3, -10,10,0);

La valeur par défaut est celle que votre codeur prendra au démarrage du programme, avant que l'utilisateur ait tourné le bouton (j'ai choisi une valeur de 0).  Lorsque l'utilisateur tournera le bouton dans le sens horaire, la valeur augmentera progressivement, par bonds de 1.   Si on atteint la valeur maximale (que j'ai réglée à 10), une rotation du bouton dans le sens horaire n'a aucun effet.  Si l'utilisateur tourne le bouton dans le sens antihoraire, la valeur diminue progressivement, sauf si la valeur minimale (que j'ai réglée à -10) est atteinte.

La bibliothèque ne gère que la rotation du bouton.  Pour vérifier si le bouton est enfoncé ou non, j'ai utilisé DigitalIn qui est une fonction régulière de mbed.

On peut vérifier le fonctionnement correct du codeur rotatif grâce à un logiciel de communication série réglé à 9200 bauds.  La position du codeur est affichée périodiquement. Au départ, la valeur affichée est celle que vous avez choisie dans votre programme comme valeur par défaut.  Cette valeur augmente lorsque vous tournez le bouton en sens horaire, et diminue lorsque vous le tournez en sens antihoraire. Lorsque vous enfoncez le bouton, un astérisque est également affiché.


Yves Pelletier   (TwitterFacebook)


mercredi 3 octobre 2018

Les cartes Wemos D1 et Wemos D1 Mini (ESP8266)

Les cartes Wemos sont des cartes de prototypage qui comportent un module ESP8266 (le modèle ESP-12F, pour être précis), mais également toute l'électronique nécessaire pour l'alimentation du microcontrôleur et sa programmation par USB.

J'admets que ma découverte des cartes Wemos est quelque peu tardive: puisque je ne me débrouillais pas trop mal avec mon vieux module ESP-12, je n'avais jamais vraiment accordé d'attention à ces cartes.

Plus précisément, je n'avais pas remarqué à quel point leur prix était devenu bas.  Sur eBay, on trouve actuellement des Wemos D1 Mini pour environ 2,50 euros et des Wemos D1 pour moins de 4 euros, alors qu'un module ESP-12F (beaucoup moins pratique) coûte à lui seul 2 euros.

Utilisation plus simple

Le principal intérêt de ces cartes, c'est qu'elles sont plus simples à utiliser qu'un simple module ESP8266.

Pour la programmation d'un module ESP8266, nous avons besoin d'un convertisseur USB-TTL fonctionnant à un niveau logique de 3,3 V. En plus d'effectuer les connections nécessaires pour l'alimentation du module et la communication avec l'ordinateur, il faut penser à brancher la broche GPIO 0 à la masse, et les broches RST et CH_PD à 3,3 V.

Rien de tout ça n'est utile avec Wemos: vous branchez la carte à un port USB de l'ordinateur, et vous êtes prêts à expérimenter.

De plus, les Wemos ont été conçus pour que l'unique entrée analogique puisse supporter une tension maximale de 3,3 V, ce qui est généralement plus pratique que la limite de 1 V du module ESP-8266.  (Les entrées numériques, elles, ne supportent que 3,3 V: ne les soumettez jamais à une tension de 5 V!)

Je me suis procuré deux modèles de cartes Wemos: le Wemos D1 (révision 1) et le Wemos D1 Mini.

Wemos D1 (révision 1)

Le modèle D1 a les dimensions exactes d'une carte Arduino Uno. On peut donc y insérer un shield conçu pour une carte Arduino conventionnelle (ce qui n'est toutefois pas une garantie que le shield fonctionnera correctement car le Wemos D1 ne dispose pas de toutes les entrées/sorties d'un Arduino Uno).

En effet, l'ESP8266 ne comporte qu'une seule entrée analogique (comparativement à 6 pour l'Arduino Uno), et 11 entrées/sorties numériques utilisables (comparativement à 14 pour l'Arduino Uno).  Pour cette raison, les broches qui correspondent habituellement aux entrées analogiques A1, A2, A3, A4 et A5 sont inactives sur le Wemos D1.  De l'autre côté de la carte, certaines broches sont dupliquées: D5 et D13, par exemple, sont toutes les deux connectées à la broche GPIO14 de l'ESP8266, alors que D6 et D12 sont toutes les deux connectées à GPIO12 et que D7 et D11 sont connectées à GPIO13.

Je suppose que vous voyez le problème que ça peut potentiellement engendrer: si vous utilisez la broche D7 pour, par exemple, contrôler une LED, vous ne pouvez pas utiliser la broche D11 pour une autre fonction, puisqu'elle sera toujours dans le même état logique que la broche D7.



Pour programmer le Wemos D1 avec l'IDE Arduino, vous devez d'abord avoir installé les extensions nécessaires à la programmation de l'ESP8266, et sélectionné "WeMos D1 R1" comme type de carte.



Dans votre programme, vous pouvez, selon votre préférence, utiliser les numéros de broches tel qu'ils sont identifiés au recto de la carte (D2, D3, D4, etc) ou les numéros de GPIO de l'ESP8266 (GPIO02, GPIO16, etc. Ces numéros sont indiqués au verso de la carte Wemos D1).

Pour utiliser le numéro indiqué au recto de la carte, vous devez impérativement utiliser la lettre "D".  Par exemple, la broche D5 sera mise au niveau logique haut avec cette syntaxe:

digitalWrite(D5,HIGH);

Puisque D5 et D13 sont branchées à la même broche de l'ESP8266, vous obtiendrez le même résultat avec:

digitalWrite(D13,HIGH);

Par contre, si vous n'utilisez par la lettre "D", vous faites alors référence au numéro de GPIO de l'ESP8266.  La commande suivante mettra au niveau logique haut la broche GPIO5, qui correspond à la broche D3 de la carte:

digitalWrite(5,HIGH);

La photographie située plus haut sur cette page indique les différentes numérotations qui peuvent être utilisées pour chaque broche de la carte (les broches dont le numéro est en rouge sont des copies de broches déjà identifiées par un numéro en noir).

(Notez que la numérotation des broches du Wemos D1 revision 2 n'est pas la même!)

Wemos D1 Mini

Le modèle D1 Mini, comme son nom l'indique est beaucoup plus petit: il est suffisamment étroit pour être inséré dans une breadboard avec une rangée de trous libre de chaque côté. De plus, il existe sur le marché une très grande variété de petit shields spécialement conçus pour cette petite carte.

Avant de pouvoir utiliser le Wemos D1 Mini, vous devez souder vous-mêmes les connecteurs. Le mien est arrivé avec un choix de 3 connecteurs: mâles, femelles, où mâle et femelle simultanément (les même connecteurs que pour un shield Arduino).



Pour programmer le Wemos D1 Mini avec l'IDE Arduino, vous devez d'abord avoir installé les extensions nécessaires à la programmation de l'ESP8266, et sélectionné "LOLIN(WEMOS) D1 R2 and mini" comme type de carte.




Pour contrôler une broche du Wemos D1 Mini, on a le choix entre utiliser le numéro qui figure sur la carte, ou le numéro de GPIO de l'ESP8266 auquel est branchée cette broche.

Par exemple, la broche "D0" de Wemos D1 Mini est reliée au GPIO16 de l'ESP8266.  On peut mettre cette broche au niveau logique haut en utilisant une des deux commandes suivantes:

digitalWrite(D0,HIGH);

digitalWrite(16,HIGH);

La photographie ci-dessous indique les différentes numérotations qui peuvent être utilisées pour chaque broche de la carte.




Yves Pelletier   (TwitterFacebook)


lundi 1 octobre 2018

Horloge Wi-Fi (ESP8266)

Le projet d'aujourd'hui consiste à utiliser un module ESP8266 afin d'obtenir l'heure et la date d'un serveur NTP (Network Time Protocol). De cette façon, nous obtiendrons une horloge qui vérifiera périodiquement, par Wi-Fi,  que l'heure qu'elle affiche est en accord avec l'heure officielle. Cette fonctionnalité peut également s'avérer utile pour toute autre application pour laquelle votre ESP8266 aurait besoin de connaître l'heure ou la date: data logging, tâches qui doivent être effectuées automatiquement à un moment particulier, etc.

Sketch 1: affichage de l'heure et de la date sur le moniteur série

Le sketch ci-dessous constitue un bon point de départ pour explorer l'utilisation d'un serveur NTP, puisque vous pouvez en faire l'essai sans qu'il soit nécessaire de brancher quoi que ce soit à votre module ESP8266. Le module communique avec un serveur NTP afin de connaître la date et l'heure. Chaque seconde, la date et l'heure sont affichées dans le moniteur série de l'IDE Arduino.  Toutes les 5 minutes, le serveur NTP est interrogé pour s'assurer que l'heure affichée est correcte (remarquez que, pour la plupart des applications, il n'est probablement pas utile d'interroger le serveur aussi souvent).

Le sketch ne nécessite l'installation d'aucune bibliothèque, mises à part celles qui sont déjà installées par défaut pour la programmation de l'ESP8266.

Le fuseau horaire est pris en compte grâce à la constante "decalage": une valeur de -4 convient au fuseau horaire de l'est de l'Amérique du Nord (c'est là que j'habite) mais si vous habitez ailleurs, il faudra certainement modifier sa valeur (je crois que 2 serait la valeur appropriée pour la France).

Même remarque concernant l'adresse choisie pour le serveur NTP. J'ai utilisé une adresse permettant d'interroger des serveurs canadiens (ca.pool.ntp.org), mais vous préférerez peut-être faire appel à un serveur situé plus près de chez vous, comme europe.pool.ntp.org ou africa.pool.ntp.org .






Sketch 2: affichage de l'heure et de la date sur un afficheur TM1638

Dans cette deuxième version, l'heure est affichée sur un afficheur à base de TM1638. Pendant que le bouton S1 est enfoncé, l'heure est remplacée par la date.




Ce sketch nécessite l'installation de la bibliothèque ErriezTM1638, et le module afficheur LED and KEY a été branché de la même façon que dans mon billet ESP8266 et afficheur à base de TM1638.




-


Yves Pelletier   (TwitterFacebook)

Related Posts Plugin for WordPress, Blogger...