mardi 6 novembre 2018

Kit: oscilloscope de poche DSO150


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...

Yves Pelletier   (TwitterFacebook)

dimanche 4 novembre 2018

ESP8266 et afficheur LCD 16 X 2

Lorsque vous créez un objet connecté au moyen d'un module ESP8266, 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.


Préparation de l'IDE Arduino

Nous allons programmer l'ESP8266 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 (voir cet article pour plus d'informations).

Connexions

L'afficheur LCD occupe 6 broches de l'ESP8266, sans compter l'alimentation (nous pouvons donc oublier toute possibilité d'utiliser un module ESP-01). 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): 3,3 V
Broche 2 de l'afficheur (VDD): GND
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

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: 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.

Yves Pelletier   (TwitterFacebook)

vendredi 2 novembre 2018

Livre: Le grand livre d'Arduino, 3e édition


Le grand livre d'Arduino
3e édition
par Erik Bartmann
Éditions Eyrolles, collection Serial Makers, 2018
528 pages

Au départ, je n'avais pas vraiment l'intention de commenter cette troisième édition du grand livre d'Arduino: après tout, j'avais déjà commenté le première édition: affaire réglée, donc.

Sauf que la 3e édition comporte tellement de changements comparativement aux deux éditions précédentes qu'une partie des commentaires que j'avais formulés à l'époque n'ont plus la moindre pertinence!

Par exemple, ma principale critique concernant la première édition était le nombre effarant de chapitres théoriques qui précédaient la première activité concrète impliquant l'Arduino:  le premier sketch était téléversé dans la carte à la page 163!  Ce problème a été réglé de façon spectaculaire dans cette nouvelle édition, puisque le premier téléchargement se fait maintenant à la page 39.

Un réaménagement majeur a donc été opéré dans les premiers chapitres du livre.  Plutôt que l'approche "d'abord la théorie, et ensuite les applications pratiques" privilégiée dans les 2 premières éditions, les informations théoriques sont maintenant présentées à l'intérieur des projets pour lesquelles elles s'avèrent pertinentes.  En ce qui me concerne, il s'agit d'une amélioration épatante.

Quelques nouveautés intéressantes: deux nouvelles options sont présentées pour programmer l'Arduino; en plus de l'IDE classique, l'auteur présente l'IDE en ligne Arduino Create (chapitre 2) et l'environnement graphique mBlock (montage 21).

On peut remarquer que la plupart des chapitres qui avaient été ajoutés dans la deuxième édition ne figurent plus dans la troisième: le chapitre sur Fritzing, et les deux projets impliquant la carte Yun ne sont plus là (le chapitre sur l'interaction entre Arduino et Raspberry Pi, par contre, a été conservé).

Tout ce qu'un débutant doit savoir me semble adéquatement couvert, mais on trouve aussi des sujets plus complexes, qu'on ne retrouve généralement pas dans les ouvrages qui s'adressent strictement aux débutants (l'initiation à la programmation orientée objet pour créer ses propres bibliothèques en est un bon exemple). C'est donc un livre qui peut vous accompagner très longtemps pendant votre apprentissage de l'Arduino.

En ce qui me concerne, les nombreuses interventions du personnage de bédé nommé Ardu sont tout aussi agaçantes que dans les éditions précédentes.  Et si on tient vraiment à conserver cet irritant personnage, pourrions-nous au moins engager un dessinateur professionnel pour le mettre en scène?

Les illustrations utiles, heureusement, sont irréprochables: nombreuses photographies (toujours en couleur) et schémas de circuit (Fritzing) en couleur aussi.

Pour vous faire votre propre opinion, voici un document pdf montrant les premières pages du livre.

Yves Pelletier   (TwitterFacebook)

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)

Related Posts Plugin for WordPress, Blogger...