Travailler avec l'affichage graphique 1602 dans Arduino. Écran LCD WH1602B de Winstar. Contrôle de l'écran LCD via le bus I2C
Est arrivé Arduino-Nano, un kit est arrivé, contenant une maquette et un écran LCD. L'affichage sur le tableau indique - 1602A, en dessous - QAPASS. J'ai commencé à sculpter le premier appareil et, bien sûr, je voulais afficher des informations sur l'écran, et non des LED clignotantes.
Google m'a aidé et m'a dit qu'il s'agissait d'un affichage de caractères ; Si vous ne le déformez pas, il est fort probable que des caractères ASCII soient disponibles - des chiffres, du latin, certains des caractères de base.
Les matériaux suivants ont contribué au lancement de l'affichage : Pilotage d'un écran LCD de type caractère à partir d'un port d'imprimante PC ; Comment connecter Arduino avec un écran LCD à caractères ; PDF de contrôle du moteur du servomoteur Pwm.
L'affichage est assez courant et des boucliers ont déjà été inventés pour cela - il existe des options avec SPI, comme et/ou avec I2C, et Internet regorge de recettes pour ces cas. Mais je n'avais que l'écran 16x2 d'origine et l'Arduino auquel je voulais le fixer.
L'afficheur a un mode de fonctionnement et de transmission de données en quartets, de 4 bits chacun, tandis que les bits de poids faible du bus ne sont pas utilisés. La connexion de seulement la moitié du bus de données est décrite à de nombreux endroits, et je n'ai pas compris comment connecter l'écran et travailler avec lui sur 8 lignes. Je suis assez content de la façon dont cela fonctionne.
Bonne description des affichages de ce genre Je l'ai trouvé ici - http://greathard.ucoz.com/44780_rus.pdf. Et ici (http://arduino.ru/forum/programmirovanie/lcd-i2c-partizanit#comment-40748) est un exemple de spécification d'un générateur de caractères.
Connexion
Mon écran était livré avec des contacts dessoudés. Dès le début, j'ai voulu souder le câble, couper 16 fils avec des duponts et les nettoyer. Et puis j'ai fouillé dans la baleine et j'ai trouvé un peigne DuPont à souder sur la carte. De là, j'ai cassé 16 contacts et les ai soudés.Mon écran ressemblait à ceci (avant de souder les contacts) :
J'ai d'abord connecté la broche 15 (A) à +5 V, 16 (K) à la masse et je me suis assuré que le rétroéclairage fonctionnait. En général, il est correct de connecter la cathode à la terre via une résistance de 220 Ohm, ce que j'ai ensuite fait.
Ensuite, j'ai connecté la masse (1) et l'alimentation (2). Arduino peut être alimenté depuis USB, à partir d'une tension stabilisée de 5 V et à partir d'un 6-12 V non stabilisé, la tension la plus élevée est automatiquement sélectionnée. Maintenant, l'Arduino est alimenté par USB et je me demandais où trouver 5 Volts. Il s'est avéré que le 5 V se trouve sur la broche Arduino, où le 5 V externe stabilisé est connecté. Ou plutôt, il s'est avéré que c'était 4,7 V, mais cela me suffisait.
Après avoir branché l'alimentation, si tout va bien, la rangée supérieure s'allume avec des rectangles pleins de familiarité.
Ensuite, nous connectons le potentiomètre de contraste (broche 3 V0). On jette l'une des bornes extrêmes du potentiomètre à la terre, la seconde au +5V, celle du milieu à la broche 3 de l'afficheur. Un potentiomètre 10K est recommandé. J'avais 50K de baleine, je l'ai utilisé en premier. Le réglage ne portait que sur un seul bord, il fallait capter le contraste souhaité de manière très subtile. Ensuite, j'en ai trouvé un similaire à 5K dans une autre baleine et je l'ai installé. Le décor s'étendait d'un bord à un demi-tour. Apparemment, vous pouvez prendre un potentiomètre encore plus petit. 10K est probablement recommandé pour que le circuit consomme moins. Oui, j'ai dû faire un peu de soudure, j'ai soudé des fils avec des duponts aux bornes des potentiomètres.
Croquis de test
Nous prenons le croquis de test à partir des exemples d'Arduino Studio - "C:\Program Files (x86)\Arduino\libraries\LiquidCrystal\ex amples\HelloWorld\HelloWorld.ino", il suffit de remplacer les contacts par les nôtres - LiquidCrystal lcd ( 7, 6, 5, 4, 3, 2);En principe, ce croquis contient également une description de ce qu'il faut connecter et où. Vous pouvez le connecter comme indiqué ici, vous n’avez alors rien à changer du tout.
// inclut le code de la bibliothèque : #include
Il s'avère que quelque chose comme ceci : 
D'ailleurs, l'écran qui m'est venu entre les mains ne fonctionne pas sans rétroéclairage. Je veux dire, ça marche, mais on ne voit presque rien.
Contacts d'affichage 1602A
| # contact | Nom | Comment se connecter |
|---|---|---|
| 1 | VSS | GND |
| 2 | VDD | +5V |
| 3 | V0 | Contraste - à la borne médiane du potentiomètre |
| 4 | RS (sélection du registre) | D7Arduino |
| 5 | R/W (lecture ou écriture) | GND |
| 6 | E (Activer le signal) | D6Arduino |
| 7-14 | J0-D7 | D0-D3 - non connecté ; D4-D7 - connecté aux broches D5-D2 de l'Arduino |
| 15 | UN | Anode de rétroéclairage, connectée au +5V |
| 16 | K | Cathode de rétroéclairage, connectée à la terre via une résistance de 220 Ohm |
L'article explique comment connecter correctement un écran LCD à Arduino, tout ce que vous devez savoir sur la connexion du LCD 1602 et du LCD i2c est couvert.
Les écrans LCD de 1602 tailles, créés sur la base du contrôleur HD44780, restent aujourd'hui parmi les plus abordables, les plus simples et les plus demandés pour le développement de tout type d'appareils électroniques.
Il n'est pas surprenant qu'ils puissent être vus aussi bien dans des unités simples assemblées littéralement sur le genou que dans des unités industrielles plus sérieuses, par exemple des machines à café. C'est avec cet écran que sont assemblés les modules et blindages Arduino les plus populaires, par exemple le module LCD I2C et le LCD Keypad Shield.
Dans les étapes suivantes, nous vous expliquerons en détail, avec des images, comment connecter l'écran LCD à l'Arduino et afficher les informations nécessaires sur l'écran.
Étape 2. LCD 1602 pour Arduino
Les écrans 1602 sont disponibles en deux modèles différents :
- rétroéclairage jaune avec lettres noires
- ou (cela arrive beaucoup plus souvent) un rétroéclairage bleu avec du blanc.
La taille des écrans du contrôleur HD44780 varie considérablement, mais ils sont contrôlés de la même manière. Les dimensions les plus courantes sont 16 x 02 (c'est-à-dire 16 caractères sur deux lignes) ou 20 x 04. Les caractères eux-mêmes ont une résolution de 5 x 8 pixels.
La plupart des écrans ne prennent pas en charge le cyrillique (à l'exception des écrans marqués CTK). Mais ce problème est partiellement résolu et l'article décrit en détail comment procéder.
L'écran dispose d'un connecteur à 16 broches pour la connexion. Les pins sont marqués au dos de la planche, c'est comme suit :
- 1 (VSS) – alimentation négative pour le contrôleur.
- 2 (VDD) – alimentation positive pour le contrôleur.
- 3 (VO) – paramètres de contrôle du contraste.
- 4 (RS) – sélection du registre.
- 5 (R/W) – lecture et écriture, en particulier écriture lorsqu'elle est connectée à la terre.
- 6 (E) – activation (activer).
- 7–10 (DB0-DB3) – bits de poids faible de l'interface à huit bits.
- 11–14 (DB4-DB7) – bits les plus significatifs de l'interface
- 15 (A) – anode positive pour l’alimentation du rétroéclairage.
- 16 (K) – cathode négative pour l’alimentation du rétroéclairage.
Étape 3. Connectez l'écran LCD
Avant de connecter l'écran et de lui transférer des informations, il convient de vérifier sa fonctionnalité. Tout d'abord, appliquez une tension aux contrôleurs VSS et VDD, allumez le rétroéclairage (A, K), puis ajustez le contraste.
Pour de tels réglages, un potentiomètre de 10 kOhm convient, sa forme n'a pas d'importance. +5V et GND sont fournis aux pattes extérieures et la patte au centre est connectée à la broche VO.
Lorsque le circuit est alimenté, vous devez obtenir le contraste nécessaire ; s'il est mal réglé, l'image sur l'écran ne sera pas visible. Pour régler le contraste, il faut « jouer » avec le potentiomètre. Lorsque le circuit est correctement assemblé et que le contraste est correctement réglé, la ligne supérieure de l'écran doit être remplie de rectangles.
Pour faire fonctionner l'affichage, une bibliothèque spéciale intégrée à l'environnement Arduino IDE est utilisée, LiquidCrystal.h, dont je parlerai ci-dessous. Il peut fonctionner en mode 8 bits et 4 bits. Dans la première option, seuls les bits de poids faible et de poids fort sont utilisés ( BB0-DB7), dans le second – uniquement les plus jeunes ( BB4-DB7).
Mais utiliser le mode 8 bits sur cet écran n'est pas une bonne décision : il n'y a presque aucun avantage en termes de vitesse, puisque son taux de rafraîchissement est toujours inférieur à 10 fois par seconde. Pour afficher du texte, vous devez connecter les broches DB7, DB6, DB5, DB4, E et RS aux broches du contrôleur. Ils peuvent être connectés à n'importe quelle broche Arduino, l'essentiel est de définir la séquence correcte dans le code.
Si le symbole souhaité n'est pas encore dans la mémoire du contrôleur, vous pouvez le définir manuellement (jusqu'à sept symboles au total). La cellule des écrans considérés a une extension de cinq pixels sur huit. La tâche de création d’un symbole consiste à écrire un masque de bits et à placer les uns aux endroits où les points doivent être éclairés et les zéros là où ils ne le devraient pas. Le schéma de connexion évoqué ci-dessus n'est pas toujours bon, puisqu'au moins six sorties numériques sont utilisées sur l'Arduino.
Étape 4. Schéma de contournement
Explorons une option pour contourner ce problème et nous débrouiller avec seulement deux. Nous avons besoin d'un module convertisseur supplémentaire pour LCD vers IIC/I2C. La façon dont il est soudé à l'écran et connecté à l'Arduino est visible dans les images ci-dessous.
Mais cette option de connexion ne fonctionne qu'avec une bibliothèque spéciale, LiquidCrystal_I2C1602V1, qui est cependant facile à trouver sur Internet et à installer, après quoi vous pouvez l'utiliser sans aucun problème.
Étape 4 : Bibliothèque LiquidCrystal.h
La bibliothèque LiquidCrystal.h peut être téléchargée depuis la section Bibliothèques de notre site Web sur cette page ou depuis la ressource officielle arduino.cc. Mais vous pouvez également télécharger à partir des liens ci-dessous :
Étape 5. Esquisse (code du programme)
Une fois que vous avez téléchargé l'archive, remplacez le dossier LiquidCrystal dans le dossier bibliothèques de votre répertoire d'installation Arduino.
Vous pouvez voir un exemple de croquis sur :
Fichier -> Exemples -> LiquidCrystal -> HelloWorld_SPI
Ou, si vous avez un menu en anglais :
Fichier -> Exemples -> LiquidCrystal -> HelloWorld_SPI
Ceci conclut notre prochaine leçon. Nous vous souhaitons des projets de qualité !
affichage LCD– un invité fréquent dans les projets Arduino. Mais dans les circuits complexes, nous pouvons avoir le problème d'un manque de ports Arduino en raison de la nécessité de connecter un blindage comportant de très nombreuses broches. La solution dans cette situation pourrait être I2C/IIC un adaptateur qui connecte un blindage Arduino 1602 presque standard aux cartes Uno, Nano ou Mega en utilisant seulement 4 broches. Dans cet article, nous verrons comment connecter un écran LCD à une interface I2C, quelles bibliothèques vous pouvez utiliser, rédigerons un court exemple de croquis et examinerons les erreurs courantes.
Affichage à cristaux liquides ACL 1602 est bon choix pour afficher des chaînes de caractères dans divers projets. C'est peu coûteux, il existe diverses modifications avec différentes couleurs de rétroéclairage, vous pouvez facilement télécharger des bibliothèques prêtes à l'emploi pour les croquis Arduino. Mais le principal inconvénient de cet écran est le fait que l'écran dispose de 16 broches numériques, dont un minimum de 6. Par conséquent, l'utilisation de cet écran LCD sans i2c ajoute de sérieuses restrictions pour les cartes Arduino Uno ou Nano. S'il n'y a pas assez de contacts, vous devrez alors acheter une carte Arduino Mega ou enregistrer des contacts, notamment en connectant l'écran via i2c.
Brève description des broches LCD 1602
Examinons de plus près les broches du LCD1602 :
Chacune des broches a son propre objectif :
- Terre à la terre ;
- Alimentation 5 V ;
- Réglage du contraste du moniteur ;
- Commande, données ;
- Écriture et lecture de données ;
- Activer;
7-14. Lignes de données ;
- Plus rétroéclairage ;
- Moins le rétroéclairage.
Spécifications d'affichage :
- Type d'affichage de caractères, il est possible de charger des symboles ;
- Lumières LED;
- Contrôleur HD44780 ;
- Tension d'alimentation 5V ;
- Formater 16x2 caractères ;
- Plage de température de fonctionnement de -20C à +70C, plage de température de stockage de -30C à +80C ;
- Angle de vision 180 degrés.
Schéma de connexion de l'écran LCD à la carte Arduino sans i2C
Le schéma standard pour connecter un moniteur directement à un microcontrôleur Arduino sans I2C est le suivant.
En raison du grand nombre de contacts connectés, il se peut qu'il n'y ait pas assez d'espace pour connecter les éléments nécessaires. L'utilisation d'I2C réduit le nombre de fils à 4 et les broches occupées à 2.
Où acheter des écrans et des blindages LCD pour Arduino
L'écran LCD 1602 (et la version 2004) est très populaire, vous pouvez donc le trouver facilement aussi bien dans les magasins en ligne nationaux que sur des sites étrangers. Voici quelques liens vers les options les plus disponibles :
 Module écran bleu LCD1602+I2C, compatible Arduino
|
 Un simple écran LCD1602 (rétroéclairage vert) moins cher que 80 roubles
|
 Grand écran LCD2004 avec I2C HD44780 pour Arduino (rétroéclairage bleu et vert)
|
 Écran 1602 avec adaptateur IIC et rétroéclairage bleu
|
 Une autre version du LCD1602 avec un module I2C soudé
|
 Module adaptateur de port IIC/I2C/TWI/SPI pour blindage 1602, compatible avec Arduino
|
 Écran rétroéclairé RVB ! LCD 16×2 + clavier + Buzzer Shield pour Arduino
|
 Shield pour Arduino avec boutons et écran LCD1602 LCD 1602
|
 Écran LCD pour imprimante 3D (Smart Controller for RAMPS 1.4, Text LCD 20×4), module lecteur de cartes SD et MicroSD
|
Description du protocole I2C
Avant de discuter de la connexion de l'écran à Arduino via un adaptateur i2c, parlons brièvement du protocole i2C lui-même.
I2C/IIC(Inter-Integrated Circuit) est un protocole créé à l'origine pour la communication circuits intégrésà l'intérieur appareil électronique. Le développement appartient à Philips. Le protocole i2c est basé sur l'utilisation d'un bus 8 bits, nécessaire à la communication des blocs dans l'électronique de contrôle, et d'un système d'adressage, grâce auquel vous pouvez communiquer sur les mêmes fils avec plusieurs appareils. Nous transférons simplement des données vers l'un ou l'autre appareil, en ajoutant l'identifiant de l'élément souhaité aux paquets de données.
Le plus circuit simple I2C peut contenir un périphérique maître (le plus souvent un microcontrôleur Arduino) et plusieurs esclaves (par exemple, un écran LCD). Chaque appareil a une adresse comprise entre 7 et 127. Il ne doit pas y avoir deux appareils avec la même adresse dans le même circuit.
La carte Arduino prend en charge i2c au niveau matériel. Vous pouvez utiliser les broches A4 et A5 pour connecter des appareils utilisant ce protocole.
Le fonctionnement I2C présente plusieurs avantages :
- Le fonctionnement ne nécessite que 2 lignes : SDA (ligne de données) et SCL (ligne de synchronisation).
- Connecter un grand nombre d’appareils leaders.
- Temps de développement réduit.
- Un seul microcontrôleur est nécessaire pour contrôler l’ensemble des appareils.
- Le nombre possible de microcircuits connectés à un bus n'est limité que par la capacité maximale.
- Haut degré de sécurité des données grâce à un filtre spécial de suppression des surtensions intégré aux circuits.
- Une procédure simple pour diagnostiquer les pannes émergentes et déboguer rapidement les pannes.
- Le bus est déjà intégré à l'Arduino lui-même, il n'est donc pas nécessaire de développer une interface de bus supplémentaire.
Défauts:
- Il y a une limite capacitive sur la ligne - 400 pF.
- Difficile de programmer un contrôleur I2C s'il y a plusieurs appareils différents sur le bus.
- Avec un grand nombre d'appareils, il devient difficile d'isoler un défaut si l'un d'entre eux devient faible par erreur.
Module i2c pour LCD 1602 Arduino
Le moyen le plus rapide et le plus pratique d'utiliser un écran i2c dans Arduino consiste à acheter un écran prêt à l'emploi avec prise en charge du protocole intégré. Mais ces écrans ne sont pas très nombreux et ils ne sont pas bon marché. Mais un grand nombre d'écrans standards différents ont déjà été produits. Par conséquent, l'option la plus abordable et la plus populaire aujourd'hui consiste à acheter et à utiliser un module I2C séparé - un adaptateur, qui ressemble à ceci :
D'un côté du module, nous voyons les broches i2c - masse, alimentation et 2 pour le transfert de données. Sur l'autre adaptateur, nous voyons des connecteurs d'alimentation externes. Et bien sûr, la carte comporte de nombreuses broches avec lesquelles le module est soudé aux broches standard de l'écran.
Les sorties i2c sont utilisées pour se connecter à la carte Arduino. Si nécessaire, nous connectons une alimentation externe pour le rétroéclairage. Avec le trimmer intégré, nous pouvons définir des valeurs de contraste personnalisées J
Sur le marché, vous pouvez trouver des modules LCD 1602 avec des adaptateurs déjà soudés ; leur utilisation est simplifiée au maximum. Si vous avez acheté un adaptateur séparé, vous devrez d'abord le souder au module.
Connexion de l'écran LCD à Arduino via I2C
Pour vous connecter, vous avez besoin de la carte Arduino elle-même, d'un écran, d'une maquette, de fils de connexion et d'un potentiomètre.
Si vous utilisez un adaptateur i2c séparé spécial, vous devez d'abord le souder au module d'écran. Il est difficile de se tromper là-bas, vous pouvez suivre ce schéma.
Un moniteur LCD avec prise en charge i2c est connecté à la carte à l'aide de quatre fils : deux fils pour les données, deux fils pour l'alimentation.
- La broche GND se connecte à GND sur la carte.
- La broche VCC est à 5V.
- SCL se connecte à la broche A5.
- SDA est connecté à la broche A.
Et c'est tout ! Pas de réseaux de fils dans lesquels il est très facile de s'emmêler. Dans le même temps, on peut simplement confier toute la complexité de la mise en œuvre du protocole i2C aux bibliothèques.
Bibliothèques pour travailler avec l'écran LCD i2c
Pour interagir avec Arduino et LCD 1602 via le bus I2C, vous aurez besoin d'au moins deux librairies :
- La bibliothèque Wire.h pour travailler avec I2C est déjà incluse dans la norme Programme Arduino IDE.
- La bibliothèque LiquidCrystal_I2C.h, qui comprend une grande variété de commandes pour contrôler le moniteur via le bus I2C et permet de rendre le croquis plus simple et plus court. Vous devez également installer la bibliothèque. Après avoir connecté l'écran, vous devez également installer la bibliothèque LiquidCrystal_I2C.h.
Après avoir connecté toutes les bibliothèques nécessaires au croquis, nous créons un objet et pouvons utiliser toutes ses fonctions. Pour les tests, chargeons l’exemple d’esquisse standard suivant.
#inclure
Description des fonctions et méthodes de la bibliothèque LiquidCrystal_I2C :
- home() et clear() - la première fonction vous permet de ramener le curseur au début de l'écran, la seconde fait de même, mais supprime en même temps tout ce qui était auparavant sur le moniteur.
- write(ch) – vous permet d’imprimer un seul caractère ch à l’écran.
- Cursor() et noCursor() – affiche/masque le curseur sur l’écran.
- clignotant() et noBlink() – le curseur clignote/ne clignote pas (si son affichage a été activé auparavant).
- display() et noDisplay() – vous permettent de connecter/désactiver l’affichage.
- scrollDisplayLeft() et scrollDisplayRight() – font défiler l'écran d'un caractère vers la gauche/droite.
- autoscroll() et noAutoscroll() – vous permettent d'activer/désactiver le mode de défilement automatique. Dans ce mode, chaque nouveau caractère est écrit au même endroit, déplaçant ce qui était précédemment écrit à l'écran.
- leftToRight() et rightToLeft() – Définition de la direction du texte affiché – de gauche à droite ou de droite à gauche.
- createChar(ch, bitmap) – crée un caractère avec le code ch (0 – 7), en utilisant un tableau de bitmaps bitmap pour créer des points noirs et blancs.
Bibliothèque alternative pour travailler avec l'affichage i2c
Dans certains cas, des erreurs peuvent survenir lors de l'utilisation de la bibliothèque spécifiée avec des appareils équipés de contrôleurs PCF8574. Dans ce cas, la bibliothèque LiquidCrystal_PCF8574.h peut être proposée comme alternative. Il étend LiquidCrystal_I2C, il ne devrait donc y avoir aucun problème pour son utilisation.
Problèmes de connexion de l'écran LCD i2c
Si après avoir téléchargé le croquis, vous ne voyez aucun message à l'écran, essayez les étapes suivantes.
Tout d'abord, vous pouvez augmenter ou diminuer le contraste du moniteur. Souvent, les caractères ne sont tout simplement pas visibles en raison du mode de contraste et de rétroéclairage.
Si cela ne résout pas le problème, vérifiez si les contacts sont correctement connectés et si l'alimentation du rétroéclairage est connectée. Si vous avez utilisé un adaptateur i2c séparé, vérifiez à nouveau la qualité de la soudure des contacts.
Une autre raison courante pour laquelle du texte manque à l'écran peut être une adresse i2c incorrecte. Essayez d'abord de changer l'adresse de l'appareil dans le croquis de 0x27 0x20 ou à 0x3F. Différents fabricants peuvent avoir différentes adresses par défaut programmées. Si cela ne résout pas le problème, vous pouvez exécuter le croquis du scanner i2c, qui analyse tous les appareils connectés et détermine leur adresse par force brute. Un exemple de croquis de scanner i2c.
Si l'écran ne fonctionne toujours pas, essayez de dessouder l'adaptateur et de connecter l'écran LCD comme d'habitude.
Conclusion
Dans cet article, nous avons examiné les principaux problèmes liés à l'utilisation d'un écran LCD dans des projets Arduino complexes, lorsque nous devons enregistrer des broches libres sur la carte. Un adaptateur i2c simple et peu coûteux vous permettra de connecter un écran LCD 1602, en n'occupant que 2 broches analogiques. Dans de nombreuses situations, cela peut être très important. Le prix de la commodité est la nécessité d'utiliser un module supplémentaire - un convertisseur et une bibliothèque. À notre avis, ce n’est pas un prix élevé à payer pour plus de commodité et nous recommandons fortement d’utiliser cette fonctionnalité dans les projets.
Qu'est-ce qui fait partie intégrante d'un grand nombre d'appareils électroniques ? Bien entendu, des moyens d'indication et de sortie graphique des données. Il est toujours plus pratique et agréable pour l'utilisateur que le résultat de la « smart box » soit visible visuellement. Par conséquent, aujourd'hui, nous allons connecter un écran au STM32 pour afficher du texte et des chiffres. Le héros de nos expériences sera un écran plutôt populaire de Winstar. À propos, une précision importante est apparue dans les commentaires selon laquelle la méthodologie est fondamentalement la même pour tous les affichages basés sur HD44780. Merci à JekaKey pour l'ajout important)
Tout d’abord, l’écran doit être connecté au contrôleur. Téléchargez la fiche technique et recherchez le brochage du WH1602. Regardez ici :
Comme tu le sais, affichage WH1602 a 16 broches. Examinons chacun séparément...
Les broches Vss, Vdd et K doivent être connectées à la masse et à l'alimentation, c'est-à-dire exactement comme indiqué dans le tableau, il n'y a pas de surprises et même rien à discuter)
La broche numéro 3 sert à régler le contraste - si on y applique du +5V, on ne verra absolument rien, et si on court-circuite la broche à la masse, on admirera deux rangées de carrés noirs 😉 Naturellement, cela ne nous convient pas , il faut donc y accrocher un potentiomètre (résistance) à résistance variable) pour régler le contraste. La meilleure visibilité des caractères est assurée par une tension de 0,5 à 0,7 V au niveau de cette broche d'affichage.
La broche RS est déjà une broche que nous contrôlerons nous-mêmes à l'aide d'un microcontrôleur. Un niveau de tension faible (0) sur cette broche signifie qu'une commande va désormais suivre, un niveau haut (1) signifie qu'il y aura désormais des données à écrire dans la mémoire d'affichage.
Pin R/W - c'est clair ici, soit nous lisons les données (afficher le drapeau occupé, par exemple), dans ce cas il y a 1 sur cette broche, soit nous écrivons la commande/les données sur l'écran, alors nous avons 0 ici.
DB7 – DB0 – bus de données, et ça veut tout dire)
La broche E est ce qu'on appelle le signal d'activation. C'est pour cela qu'il est nécessaire. Pour travailler avec l'écran - enregistrer des données ou émettre une commande - nous devons émettre une impulsion positive sur cette broche. Autrement dit, la procédure ressemblera à ceci :
- Sur les broches RS, R/W, DB7 - DB0 - les signaux nécessaires correspondant à notre commande.
- Nous en fournissons un à la broche E.
- Zhdems (selon la fiche technique – au moins 150 ns)
- Nous appliquons un niveau bas (0) à la broche E.
Vous devez mettre 4,2 V sur la jambe A/Vee pour alimenter le rétroéclairage de l'écran.
C'est ainsi que s'effectue la communication avec l'écran WH1602.
Nous avons compris comment connecter le WH1602, mais avant de passer à l'exemple, regardons quelles commandes notre écran comprend généralement. Pour ce faire, on va dans la datasheet et on trouve un tableau intéressant :
Toutes les commandes et signaux qui doivent être sur les broches correspondantes du WH1602 pour chaque commande spécifique sont décrits ici. Par exemple, nous voulons effacer l'affichage, nous regardons le tableau, et voici la commande dont nous avons besoin ! Affichage clair !
Nous appliquons des zéros aux broches RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 et un à la broche DB0. Terminé ! Quelle est la prochaine étape ? C'est vrai, un sur la broche E, puis attendez un moment et abaissez à nouveau E à zéro. Ça y est, l'affichage est effacé 😉 Juste avant d'exécuter la commande suivante vous devez faire une pause, indiquée dans la fiche technique de chaque commande. Il serait plus efficace d'interroger l'indicateur d'occupation ; dès qu'il est remis à 0, vous pouvez continuer à travailler. Il existe également une commande spéciale pour lire ce drapeau, donc tout est clair avec ceci) Passons à autre chose...
Et, en fait, tout est théorique, vous pouvez déjà essayer d'écrire quelque chose. Pour faciliter le travail avec l'écran, j'ai créé une petite bibliothèque, voyons maintenant comment elle peut être utilisée. Tout d'abord, téléchargez
Nous disposons de 2 fichiers, MT_WH1602.c et MT_WH1602.h. On arrache le second, ici il faut sélectionner les broches et le contrôleur utilisé.
Au fait, mon écran est connecté comme ceci :
RS-PC2
R/É – PB10
E-PB14
DB7–PD2
DB6-PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5
Ouvrez le fichier MT_WH1602.h :
| #define PLATEFORME (STM32F10x) |
Ensuite, sélectionnez les broches du microcontrôleur auxquelles l'écran est connecté. Commençons par définir les ports que nous utilisons. Quand je me connecte, j'utilise GPIOA, GPIOB, GPIOC et GPIOD, on écrit :
De même pour les autres pattes du microcontrôleur.
Nous avons terminé la configuration, continuons) Pour appeler les commandes données en début d'article, le fichier MT_WH1602.c contient les fonctions suivantes (elles portent le nom des noms des commandes, donc je pense que tout est clair) :
| void MT_WH1602_ClearDisplay(void) ; void MT_WH1602_ReturnHome(void) ; void MT_WH1602_EntryModeSet (bool IDaddress, bool shift) ; void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; void MT_WH1602_CursorOrDisplayShift (bool SCbit, bool RLbit) ; void MT_WH1602_FunctionSet (bool DLbit, bool Nbit, bool Fbit) ; void MT_WH1602_SetCGRAMAddress (adresse uint8_t) ; void MT_WH1602_SetDDRAMAddress (adresse uint8_t) ; bool MT_WH1602_ReadBusy(void) ; void MT_WH1602_WriteData(uint8_t données) ; |
Pour certaines commandes, nous devons passer des paramètres à la fonction, par exemple :
| void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit) ; |
Regardons le tableau des commandes :
Nous voyons que la commande Display ON/OFF non seulement allume/éteint l'affichage, mais active/désactive également le curseur et le clignotement du curseur. Dans la fiche technique, ces bits de commande sont désignés par D, C et B, et nous les transmettons comme paramètres à la fonction. Si nous devons allumer l'écran et le curseur, mais désactiver le clignotement du curseur, nous appelons la commande comme suit :
MT_WH1602_DisplayOnOff(1, 1, 0);
En général, tout est simple 😉
Bref, nous créons nouveau projet, ajoutez une bibliothèque pour travailler avec l'écran WH1602, créez un fichier .c vide et commencez à le remplir de code :
| // Inclut le fichier bibliothèque#inclure "MT_WH1602.h" /*******************************************************************/ int principal (vide) ( // Appel de la fonction d'initialisation, on ne peut plus s'en passer =)() ; // Nous devons maintenant effectuer la configuration initiale de l'affichage // La documentation et Internet recommandent de le faire ;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000 ) ; MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000 ) ; MT_WH1602_ClearDisplay() ; MT_WH1602_Delay(2000) ; // Par exemple, j'ai pris les premières valeurs de retard qui me sont venues à l'esprit) // En général, vous devez vérifier l'indicateur d'affichage occupé // Affichons maintenant quelque chose, comme le nom de notre site MT_WH1602_WriteData(0x6D) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6F) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x74) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x65) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x68) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x6E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x69) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x63) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x73) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x2E) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x72) ; MT_WH1602_Delay(100) ; MT_WH1602_WriteData(0x75) ; MT_WH1602_Delay(100) ; tandis que (1 ) ( __NOP() ; ) ) /*******************************************************************/ |
C'est fait, vérifions) 
Comme vous pouvez le constater, tout fonctionne correctement)
D'ailleurs, j'ai en quelque sorte perdu de vue la question de savoir quoi écrire sur l'écran pour afficher tel ou tel caractère. Voici la plaque de la fiche technique : 
Ainsi, afin de déterminer quelle valeur écrire dans la mémoire d'affichage, vous devez prendre les nombres écrits en haut et à gauche dans ce tableau pour un symbole spécifique. Par exemple, le symbole « A ». Voyons voir - ce symbole correspond à la colonne 0100 (0x4) et à la ligne 0001 (0x1). Il s'avère que pour afficher le symbole « A », vous devez écrire la valeur 0x41 sur l'écran.
Ça y est maintenant =) Nous avons réglé le branchement et le fonctionnement de l'afficheur WH1602, alors à bientôt !
P.S. Lorsque je travaillais avec la bibliothèque, je n'ai pas testé la fonction de lecture du drapeau occupé, donc si soudainement quelque chose ne fonctionne pas comme il se doit, écrivez, nous le découvrirons)
Parfois, nous sommes confrontés au problème de la transmission de diverses informations d'Arduino vers le monde extérieur. Souvent, l'utilisation d'un port série est impossible, peu pratique et peu rentable.
Un affichage de caractères est l’un des moyens d’affichage d’informations les plus simples et les moins chers car il possède son propre microcontrôleur qui stocke les caractères codés. Ce système simplifie l'utilisation de ces écrans, mais limite en même temps leur utilisation à la sortie uniquement informations textuelles, contrairement aux affichages graphiques.
Dans l'exemple, nous examinerons l'écran Winstar wh1602l1, l'un des écrans les plus courants sur le contrôleur hd44780. De plus, vous pouvez connecter un LCD 2004 et d'autres similaires.
Les deux premiers chiffres indiquent le nombre de caractères par ligne, et le second le nombre de lignes, l'affichage sélectionné comporte donc 2 lignes de 16 caractères.
Cette méthode de connexion implique d'occuper au moins 6 ports du microcontrôleur Arduino. Si nécessaire, vous pouvez connecter l'afficheur de texte 1602 via l'interface I2C (2 ports).
Parmi les éléments supplémentaires dont nous avons besoin Resistance variable, pour contrôler le contraste. Sinon, tout est connecté selon le schéma, selon la fiche technique et les sorties Arduino sélectionnées dans le programme.
Les broches 15 et 16 de l'écran sont responsables du rétroéclairage ; il peut être désactivé ou la luminosité peut être ajustée automatiquement lors de la connexion d'une photorésistance à l'Arduino en tant que capteur de luminosité.
Dans notre exemple, nous allons lire les données du port série et les afficher sur l'écran :
#inclure
Vous pouvez compliquer le code et afficher l'horloge en temps réel DS1307 sur Arduino sur votre LCD1602.
Examinons maintenant de plus près toutes les fonctions de la bibliothèque Liquide Crystal:
La première et la plus importante chose est qu'en utilisant cette bibliothèque, vous ne pouvez pas afficher les lettres russes, même si l'écran a ces caractères en mémoire. Ce problème peut être résolu soit par d'autres bibliothèques, soit en écrivant des valeurs en utilisant du code hexadécimal.
lcd.print();- le plus simple et le plus fréquemment utilisé, utilisé pour afficher des informations.
écran LCD. clair(); - utilisé pour nettoyer l'écran.
lcd.setCursor(X, oui); - place le curseur à un endroit précis.
X – changement de position dans la ligne
Y – changement de ligne
Par exemple, lcd.setCursor(0, 0); c'est la cellule en haut à gauche.
lcd.home(); - place le curseur à la position 0, 0
lcd.home(); = lcd.setCursor(0, 0);
écran LCD. scrollAffichageGauche(); - décaler vers la gauche
écran LCD. scrollDisplayRight(); - décaler vers la droite
Lcd.createChar(Nom, tableau); - créer votre propre enseigne.
Par exemple, le signe du degré ressemble à ceci :
Celc = (B00111, B00101, B00111, B00000, B00000, B00000, B00000, B00000 );
