Explications pour le code :

1. la bibliothèque LiquidCrystal_I2C.h contient de nombreuses commandes pour contrôler l'écran LCD via le bus I²C et vous permet de simplifier considérablement l'esquisse ;
2. l'esquisse contient un commentaire multiligne /* ... */ , qui vous permet de commenter plusieurs lignes dans le programme à la fois.
3. avant d'afficher des informations sur l'écran, vous devez définir la position du curseur avec la commande setCursor(0,1), où 0 est le numéro de caractère dans la ligne, 1 est le numéro de ligne.

Dans la leçon, nous parlerons des indicateurs à cristaux liquides synthétisant les signes, en les connectant à la carte Arduino et en contrôlant les indicateurs à l'aide des bibliothèques LiquidCrystal et LiquidCrystalRus.

Les indicateurs LED à sept segments, bien qu'ils soient l'option d'indication la moins chère pour les appareils électroniques, leur utilisation est limitée par deux inconvénients importants.

• Il est pratiquement difficile de connecter plus de 8 chiffres d'indicateurs LED au microcontrôleur. Nécessite un grand nombre de sorties, des courants de voyants importants, des touches complexes, basse fréquence régénération, etc...
• Il n'est pas possible d'afficher des informations de caractères sur des affichages à sept segments.

Pour afficher des informations textuelles ou des nombres supérieurs à 4 chiffres, il est beaucoup plus pratique d'utiliser des indicateurs à synthèse de caractères à cristaux liquides (afficheurs). Leurs avantages incluent :

• interface pratique pour la connexion aux microcontrôleurs ;
• Basse consommation énergétique;
• basse tension d'alimentation ;
• durabilité.

Il existe une grande variété d'écrans à cristaux liquides (LCD) sur le marché. différents fabricants. Presque tous sont similaires dans les paramètres, les signaux d'interface, les commandes de contrôle. DANS ce moment les indicateurs LCD les plus courants sur Marché russe sont des appareils fabriqués par Winstar, Taiwan. Je me référerai aux indicateurs de cette firme. Mais les informations sont tout à fait applicables aux écrans LCD à caractères d'autres fabricants.

Informations générales.

Les indicateurs de synthèse de signes ou symboliques affichent des informations sous forme de familiarité d'une certaine profondeur de bits. Un caractère représente un caractère. Le nombre de familiarité détermine la profondeur de bits de l'indicateur. Les informations sur les indicateurs peuvent être affichées sur plusieurs lignes, ainsi pour les indicateurs de ce type, le nombre de caractères par ligne et le nombre de lignes sont toujours indiqués.

Les informations sont affichées sur une matrice à cristaux liquides avec Rétro-éclairage LED. Le rétroéclairage est le plus Couleurs différentes, qui anime considérablement les informations textuelles monochromes.

Pour contrôler la matrice à cristaux liquides et organiser l'interface de l'indicateur, le contrôleur HD44780 intégré ou son analogues complets. Ce contrôleur définit les signaux d'interface de l'indicateur et les commandes de contrôle.

Le HD44780 est devenu la norme de facto pour les écrans à cristaux liquides (LCD) à caractères. Documentation technique du contrôleur HD44780 Format PDF peut être consulté sur ce lien. Peut-être que quelqu'un aimera la documentation de l'un des analogues de ce contrôleur - SPLC780D. Lien PDF - .

Indicateurs LCD à caractères de Winstar.

Je connais les options suivantes pour les indicateurs LCD de cette société.

Connexion de l'indicateur LCD au microcontrôleur.

Les schémas de connexion, les chronogrammes, les paramètres de signal, les commandes de contrôle, les codes de caractères sont décrits en détail dans la documentation du contrôleur HD44780. Je ne donnerai que les données les plus nécessaires sur la connexion des indicateurs aux microcontrôleurs.

En règle générale, les indicateurs LCD ont 16 broches.

Le numéro de broche (première colonne) correspond à la variante la plus courante. Mieux vaut vérifier en téléchargeant la documentation de votre type d'indicateur à partir du tableau de la section précédente.

Les écrans LCD à caractères prennent en charge deux options de connexion au microcontrôleur :

• Utilisation d'un bus de données 8 bits. Tous les signaux de bus DB0-DB7 sont connectés. Dans un cycle d'échange, un octet d'information est transmis.
• Utilisation d'un bus de données 4 bits. Seuls les 4 MSB de DB4-DB7 sont connectés. Les informations sont transmises quatre bits par cycle de bus.

La première option permet le transfert de données vers l'affichage avec plus vite. Le second nécessite 4 sorties en moins pour connecter l'indicateur. Sans aucun doute, il est plus important de réduire le nombre de broches de connexion que d'augmenter le taux de change. De plus, les indicateurs LCD sont des appareils plutôt lents avec un temps de cycle de rafraîchissement de 10 à 20 ms.

Connexion d'un écran LCD à caractères (LCD) à la carte Arduino.

Je connecterai l'indicateur WH2004A (4 lignes de 20 caractères chacune) en mode d'échange à quatre bits à la carte Arduino UNO R3. Documents pour affichage LCD WH2004 peut être consulté sur ce lien.

Le schéma ressemble à ceci.

Les résistances R2 et R3 déterminent le contraste de l'indicateur. Vous pouvez connecter une résistance de réglage et régler la clarté d'image requise. J'utilise souvent des indicateurs WH2004 et dans mes circuits, je choisis de telles valeurs de résistance.

J'ai connecté les LED de rétroéclairage des indicateurs à une source d'alimentation de 5 V via une résistance R1 (30 Ohm). Avec cela, j'ai réglé le courant à environ 25 mA. Sombre, mais brillant. On voit bien dans le noir. Bien que les indicateurs WH2004 autorisent un courant de rétroéclairage jusqu'à 580 mA.

Bibliothèque de contrôle des indicateurs LCD dans le système Arduino LiquidCrystal.

Il existe une bibliothèque standard pour contrôler les indicateurs LCD basée sur le contrôleur HD44780. Je vais décrire ses méthodes en détail.

Liquide Crystal(…)

Constructeur de classe. Peut avoir un nombre différent d'arguments.

• LiquidCristal (rs, en, d4, d5, d6, d7) - interface à quatre bits, le signal RW n'est pas utilisé (connecté à la terre).
• LiquidCristal (rs, rw, en, d4, d5, d6, d7) - interface à quatre bits, le signal RW est utilisé.
• LiquidCristal (rs, en, d0, d1, d2, d3, d4, d5, d6, d7) - interface huit bits, signal RW non utilisé (connecté à la terre).
• LiquidCristal (rs, rw, en, d0, d1, d2, d3, d4, d5, d6, d7) - interface à huit bits, le signal RW est utilisé.

Arguments:

• rs est le numéro de sortie du signal RS ;
• rw – numéro de sortie du signal RW ;
• en est le nombre de signaux de sortie E ;
• d0, d1, d2, d3, d4, d5, d6, d7 sont les numéros de broches du bus de données.

Affichage LiquidCrystal(6, 7, 2, 3, 4, 5);

void begin(cols, rows)

Initialise l'interface de l'indicateur. Définit la dimension de l'indicateur. La méthode doit être appelée en premier, avant d'utiliser d'autres fonctions de classe.

Arguments:

• cols - le nombre de caractères dans la chaîne ;
• lignes est le nombre de lignes.

affichage.begin(20, 4); // utiliser l'afficheur - 4 lignes de 20 caractères

vide clair()

Vider l'écran en plaçant le curseur dans le coin supérieur gauche.

affichage.clear(); // réinitialiser l'affichage

voidhome()

Positionnement du curseur dans le coin supérieur gauche.

disp.home(); // vers le haut de l'écran

void setCursor(col, row)

Place le curseur à la position donnée.

• col – coordonnée X, numérotation à partir de 0 ;
• rangée - coordonnée Y, numérotation à partir de 0.

setCursor(0,1); // curseur au début de la deuxième ligne

écriture d'octets (données)

Affiche un caractère à l'écran. Renvoie le nombre d'octets transférés.

Le croquis suivant affiche les données de port série. Les données peuvent être transmises par le moniteur de port Arduino IDE.

// sortie de données du port série sur l'indicateur LCD
#inclure


chardata ;

void setup()
{
Série.begin(9600); // initialiser le port série
affichage.begin(20, 4); //
}

boucle vide ()
{
if (Serial. available()) ( // s'il y a des données
data= Serial.read(); // lit le caractère
if((data != 0xd) && (data != 0xa)) ( // saut de ligne
affichage. écriture (données); // afficher un caractère à l'écran
}
}
}

J'ai un grand indicateur - 4 lignes de 20 caractères. Il dispose de deux contrôleurs HD44780. Par conséquent, les caractères transmis séquentiellement remplissent d'abord la première ligne, puis la troisième, puis la deuxième et la quatrième. Ceux. à travers la ligne. Cette propriété doit être prise en compte pour certains types d'indicateurs. La documentation de chaque indicateur LCD indique la séquence d'adressage des caractères.

impression d'octets (données)

Affiche du texte à l'écran. Renvoie le nombre d'octets transférés.

Arguments:

data - données à afficher à l'écran. Ils peuvent avoir des types char, byte, int, long, string.

Il peut y avoir un deuxième argument facultatif.

impression d'octets (données, base)

• BASE - définit le système de numérotation :
• BIN - binaire ;
• DEC - décimal ;
• OCT - octal :
• HEX est hexadécimal.

Un exemple de programme qui imprime une chaîne de texte sur l'écran.

// conclusion chaîne de texte sur l'indicateur LCD
#inclure

Affichage LiquidCrystal(6, 7, 2, 3, 4, 5); // crée un objet

void setup()
{
affichage.begin(20, 4); // initialiser l'afficheur 4 lignes de 20 caractères
disp.print("Tester la chaîne");
}

boucle vide ()
{ }

vider le curseur()

Active le mode d'affichage du curseur. La position où le caractère suivant sera affiché est soulignée.

disp.curseur(); // activer l'affichage du curseur

annuler noCursor()

Désactive l'affichage du curseur.

disp.noCursor(); // désactiver l'affichage du curseur

annuler le clignotement()

Active le mode curseur clignotant. Utilisé conjointement avec la fonction curseur(). Le résultat dépend de modèle spécifique indicateur.

affichage.clignotement(); // activer le curseur clignotant

annuler noBlink()

Désactive le mode curseur clignotant.

disp.noBlink(); // désactiver le curseur clignotant

annuler l'affichage()

Allume l'écran après qu'il a été éteint par la fonction noDisplay(). L'écran affichera les informations qui étaient avant l'arrêt.

display.display(); // allumer l'écran

annuler aucun affichage ()

Éteint l'écran. Les informations sont stockées en mémoire et apparaissent lorsque l'écran est allumé.

disp.noDisplay(); // éteindre l'écran

annuler scrollDisplayLeft()

Fait défiler le contenu de l'affichage d'un caractère vers la gauche.

affichage scrollAfficheGauche(); // tout décaler vers la gauche

annuler scrollDisplayRight()

Fait défiler le contenu de l'affichage d'un caractère vers la droite.

affichage scrollDisplayRight(); // déplacer tout vers la droite

annuler le défilement automatique()

Activer le défilement automatique du texte. À chaque sortie de caractère, tout le texte à l'écran se décale d'un caractère. La direction dans laquelle les informations sont décalées est déterminée par les fonctions leftToRight() et rightToLeft().

affichage défilement automatique()(); // activer le défilement automatique

annuler noAutoscroll()

Désactivez le défilement automatique du texte.

affichage pas de défilement automatique ()(); // désactiver le défilement automatique

annuler leftToRight()

Définit le mode de sortie de test de gauche à droite. De nouveaux symboles apparaîtront à droite des précédents.

de gauche à droite(); // mode de gauche à droite

annuler rightToLeft()

Définit le mode de sortie de test de droite à gauche. De nouveaux personnages apparaîtront à gauche des précédents.

de droite à gauche(); // mode de droite à gauche

void createChar(num, données)

Méthode de création d'un symbole personnalisé. Le contrôleur permet de créer jusqu'à 8 caractères (0…7) d'une taille de 5x8 pixels. L'image du caractère est donnée par un tableau de 8 octets. Les 5 bits les moins significatifs de chaque octet déterminent l'état des pixels de la ligne.

Pour sortir un caractère personnalisé, vous pouvez utiliser la fonction write() avec un numéro de caractère.

// création d'un symbole personnalisé
#inclure

Affichage LiquidCrystal(6, 7, 2, 3, 4, 5); // crée un objet

octet sourire =(
B00000000,
B00010001,
B00000000,
B00000000,
B00010001,
B00001110,
B00000000,
B00000000
};

void setup()
{
disp.createChar(0, sourire); // crée un symbole
affichage.begin(20, 4); // initialiser l'afficheur 4 lignes de 20 caractères
disp.print("Sourire");
affiche.write(byte(0)); // caractère de sortie
}

boucle vide ()
{ }

Voici un exemple de programme qui affiche l'alphabet russe.

// dérivation de l'alphabet russe
#inclure

Affichage LiquidCrystalRus(6, 7, 2, 3, 4, 5); // crée un objet

void setup()
{
affichage.begin(20, 4); // initialiser l'afficheur 4 lignes de 20 caractères
disp.print("abvgdejzijklmnoprst");
disp.print("ABCDEJZYKLMNOPRST");
disp.print("uhhhhhhhhhhhhhhh");

Basés sur le contrôleur HD44780, les écrans LCD 1602 sont toujours l'un des écrans les plus abordables, les plus simples et les plus demandés pour développer tout type d'appareils électroniques aujourd'hui. Il n'est pas surprenant qu'ils puissent être vus à la fois dans des unités simples assemblées littéralement sur le genou et dans des unités industrielles plus sérieuses, telles que des machines à café. C'est avec un tel affichage que les modules et shields les plus populaires sur le thème Arduino sont assemblés, par exemple, le module LCD I2C et le LCD Keypad Shield.

Cet article explique en détail avec des images comment connecter un LCD à Arduino et afficher des informations.

1602 écrans ont deux versions différentes:

Rétroéclairage jaune avec lettres noires
- ou (cela arrive beaucoup plus souvent) rétroéclairage bleu avec du blanc.

Les dimensions des écrans du contrôleur HD44780 sont très différentes, mais ils sont contrôlés de la même manière. Les dimensions les plus courantes sont 16 par 02 (c'est-à-dire 16 caractères sur deux lignes) ou 20 par 04. Les caractères eux-mêmes ont une résolution de 5 par 8 pixels.

La plupart des affichages ne prennent pas en charge le cyrillique (à l'exception des affichages de marquage CTK). Mais un tel problème est partiellement résoluble, puis l'article détaille comment le faire.

L'écran dispose d'un connecteur à 16 broches pour la connexion. Les conclusions ont marquage au dos de la planche, il est le suivant :

1 (VSS) - puissance à moins 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 pour le registre.
5 (R/W) - lecture et écriture, en particulier, écriture lorsqu'il est connecté à la terre.
6 (E) – activation (activer).
7-10 (DB0-DB3) - bits bas de l'interface huit bits.
11-14 (DB4-DB7) - bits les plus significatifs de l'interface
15 (A) - anode positive pour alimenter le rétroéclairage.
16 (K) - cathode négative pour alimenter le rétroéclairage.

Étape 2 : connexion de l'écran LCD

Avant de connecter l'écran et de lui transférer des informations, il convient de vérifier ses performances. Tout d'abord, appliquez une tension aux contrôleurs VSS et VDD, allumez le rétroéclairage (A, K), puis réglez le contraste. Pour de tels réglages, un potentiomètre de 10 kΩ convient, sa forme n'a pas d'importance. + 5V et GND sont appliqués aux jambes extrêmes, et la jambe au centre est connectée à la sortie VO.

Lorsque l'alimentation est appliquée au circuit, il est nécessaire d'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é, rangée du haut l'écran doit se remplir de rectangles.

Pour que l'affichage fonctionne, l'Arduino intégré est utilisé. Environnement EDI bibliothèque spéciale LiquidCrystal.h, dont je parlerai ci-dessous. Il peut fonctionner en mode 8 bits et 4 bits. Dans la première variante, seuls les bits bas et hauts (BB0-DB7) sont utilisés, dans la seconde, seuls les bits bas (BB4-DB7).

Mais en appliquant le mode 8 bits dans cet affichage - mauvaise décision, il n'y a presque aucun avantage en termes de vitesse, puisque son taux de mise à jour 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. Vous pouvez les connecter à n'importe quelle broche Arduino, l'essentiel est de définir la séquence correcte dans le code.

Si le caractère requis n'est pas encore dans la mémoire du contrôleur, il peut être déterminé manuellement (jusqu'à sept caractères au total). La cellule des affichages considérés a une extension de cinq par huit points. La tâche de créer un symbole consiste à écrire un masque de bits et à en placer des aux endroits où les points devraient brûler et des zéros là où ils ne le devraient pas.

Le schéma de connexion décrit ci-dessus n'est pas toujours bon, car l'Arduino utilise au moins six sorties numériques.

Étape 3 : Schéma de contournement

Explorons un moyen de contourner cela et de nous débrouiller avec seulement deux. Un module convertisseur LCD vers IIC/I2C supplémentaire est nécessaire. La façon dont il est soudé à l'écran et attaché à l'Arduino peut être vue dans les images ci-dessous.

Mais cette option de connexion ne fonctionne qu'avec la bibliothèque spéciale LiquidCrystal_I2C1602V1, qui est cependant facile à trouver sur le Web et à installer, après quoi vous pouvez l'utiliser sans problème.

Étape 4 : Bibliothèque LiquidCrystal.h

La bibliothèque LiquidCrystal.h peut être téléchargée à partir de la ressource officielle - . Vous pouvez également télécharger à partir des liens ci-dessous :

Esquisser

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 dans Fichier -> Exemples -> LiquidCrystal -> HelloWorld_SPI(Fichier -> Exemples -> LiquidCrystal -> HelloWorld_SPI).

Ceci conclut notre prochaine leçon. Nous vous souhaitons des projets de qualité !

Comment se lier d'amitié avec une carte Arduino avec un affichage de caractères ? Assez simple! Tout est ci-dessous dans l'ordre et avec des détails.

Si vous souhaitez recevoir des informations d'Arduino sans vous connecter à un ordinateur et sortir sur un port série, vous pouvez utiliser un affichage de caractères. Ce n'est pas si difficile à faire. La commodité tirée de la communication est inestimable.
Pour le travail, j'ai utilisé un écran LCD à caractères J204A basé sur la puce HD44780, souvent trouvé sur eBay sous le nom de LCD2004. 4 lignes de 20 caractères, inversées. Acheté avec un tas d'autres sur eBay, pour quelques centimes, de 60 à 100 roubles pièce. La langue russe n'est pas prise en charge par défaut, mais c'est un problème résoluble, plus à ce sujet la prochaine fois. Et les connecteurs sur le schéma ne sont pas soudés, il faudra travailler avec un fer à souder.
La bibliothèque est utilisée pour travailler avec des écrans. LiquidCrystal.h inclus dans l'IDE Arduino par défaut.

Mais je n'ai pas trouvé de fiche technique pour l'écran LCD2004, mais sur Internet, il y a beaucoup de tableaux sur l'écran. Mais ils ne diffèrent pratiquement pas les uns des autres. Le contrôle et la connexion sont complètement identiques. La différence réside uniquement dans le nombre de lignes/caractères à l'écran. Mais cela n'affectera absolument pas si vous avez 1602.

Tous les contacts sont définis dans le tableau. Si vous prenez l'écran et que vous le tournez vers vous, les contacts seront situés de gauche à droite, respectivement, dans le tableau où ils vont en nombre croissant. Dans la colonne des contacts, entre parenthèses, la désignation dans la fiche technique est indiquée.

v

Le transfert de données vers l'afficheur est possible en deux versions : 8 et 4 bits par cycle. Parce que Arduino a peu de contacts, nous en utiliserons 4 - c'est plus que suffisant pour mettre à jour les informations sur l'écran à une vitesse au-delà de la perception.

C'est ainsi que j'ai tout connecté. Cela peut sembler chaotique, mais il y a un système. Vous pouvez sélectionner des fils rouge, vert, jaune et orange. Les rouges vont toujours à + 5V, les verts vont à GND, et les jaunes et oranges sont les fils de connexion à l'Arduino, qui transportent des données.

La partie la plus importante est connexion physique afficher. Cliquez pour ouvrir dans haute résolution où tout est clairement visible.
R1 - Résistance 200OM. Résistance limitant le courant traversant le rétroéclairage de l'afficheur.
R2 - Potentiomètre avec résistance jusqu'à 10kOM. On roule le stylo, on sélectionne le contraste des caractères.

Et un croquis extrêmement simple pour afficher quelques lignes à l'écran.

H> // Nous connectons la bibliothèque pour travailler avec l'affichage. /* LCD LiquidCrystal (rs, activer, d4, d5, d6, d7); créer variable de type LiquidCrystal Et nous déterminons par quels contacts l'Arduino fonctionne avec l'écran. plus d'informations sur cette commande ici http://arduino.cc/en/Reference/LiquidCrystalConstructor */ LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() ( lcd.begin(20, 4); // définit les caractéristiques d'affichage (20 caractères par ligne, 4 lignes) // Pour l'affichage 1602, spécifiez lcd.begin(16, 2); lcd.setCursor(1, 1); // Spécifiez à partir de quelle position commencer à produire du texte. les lignes et les caractères commencent à partir de 0 !!! // 1 déplacera déjà le caret d'une division depuis le début de l'écran et décalera le texte d'une ligne en dessous de lcd.print( "compblog.vlukyanov" ); // imprime le texte à partir de la position spécifiée. lcd.setCursor(7, 2); // imprime à partir du 8e caractère à l'écran sur la troisième ligne. lcd.print(".com") ; // texte à imprimer. ) void loop() ( // ne rien faire d'autre dans la boucle, tout est déjà fait lors de l'initialisation de la carte. )

Résultat. Si vous savez comment tout cela se connecte et comment écrire du code, le temps pour tout le travail est de 5 minutes.

De plus, l'écran peut exécuter certaines fonctions par lui-même et il est également possible de définir certains paramètres.

Par exemple:

• Faites défiler le texte ;
• Clignotement de la position du curseur ;
• Allume / éteint.

Et maintenant le bonus !
Le rétroéclairage de l'écran consomme de l'énergie, ce qui, par exemple, voudrait économiser sur la batterie. J'ai fait cette option pour moi-même - lorsque vous appuyez sur le bouton, le rétroéclairage de l'écran s'allume pendant 5 secondes.

H> // Nous connectons la bibliothèque pour travailler avec l'affichage. bouton intInt = 0 ; // Numéro d'interruption à appeler. int screenLed = 4 ; // Le numéro de la broche à laquelle l'écran est connecté. +5V volatil long x = 5000 ; // variable pour stocker le temps LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() ( attachInterrupt(buttonInt, screenon, FALLING); // paramètres d'interruption lcd.begin(20, 4); pinMode(screenLed, OUTPUT); digitalWrite(screenLed, HIGH); // activer l'affichage lcd.setCursor( 0 , 0); lcd.print("Start screenon test!"); ) // La fonction qui sera exécutée lorsque le bouton sera cliqué. void screenon() ( x = millis()+5000; // Souvenez-vous du temps nécessaire pour éteindre le rétroéclairage. Temps d'exécution actuel +5 secondes. digitalWrite(screenLed,HIGH); // Appliquez une tension au rétroéclairage de l'affichage. ) void loop () ( lcd.setCursor(0, 2); // aller à la troisième ligne lcd.print(x); // et imprimer l'heure à laquelle l'affichage s'éteint lcd.setCursor(0, 3); // aller à la quatrième ligne lcd.print( millis()); // print heure actuelle fonctionne si (x< millis()) // если время работы выключения наступило >( digitalWrite (screenLed, LOW); // puis éteint l'affichage ) )

Et le résultat :