Aujourd'hui, nous allons essayer de nous attarder sur la sortie vers un affichage de texte. La plus populaire est la puce HD44780 (ou KS0066 compatible avec celle-ci). Nous listons leurs avantages et inconvénients :

Avantages:

1. Bas prix.
2. Facile à programmer, le code sera le même pour tous les modèles.
3. Variété de modèles - les plus courants : 8x1, 16x2, 20x4. Vous pouvez également trouver des modèles 40x4 plutôt exotiques, c'est-à-dire quatre lignes de 40 caractères chacune.
4. Possibilité de connecter plusieurs écrans à un seul Arduino.
5. Possibilité de définir vos propres symboles.

Moins :

1. Tous les écrans ne prennent pas en charge les caractères russes. Pour plus de détails, reportez-vous à la description d'un affichage spécifique.
2. La connexion sans utiliser le bus I2C nécessite l'utilisation de 10-16 fils, ce qui est très mauvais. avec I2C - 4 fils.

Sur la base de ce qui précède, je n'envisagerai de connecter l'écran que via I2C.

Essayons.

Ce dont nous avons besoin.

1. Arduino (j'ai pris le modèle Nano)
2. Affichage sur puce HD44780 avec ou sans module I2C (vous avez alors besoin d'une carte IIC LC1602 séparée) - dans notre cas 16x2 sans module I2C
3. Résistance 10K (si vous avez besoin d'un contrôle manuel du rétroéclairage).
4. Potentiomètre (si vous avez besoin d'un contrôle manuel du rétroéclairage).
5. Planche à pain.
6. Bibliothèque LiquidCrystal_I2C.

Petite digression #1 : Comment distinguer un afficheur avec un module I2C ?

En fait, tout est assez simple. Si, en retournant l'écran, nous voyons un long bloc de connecteurs (généralement 16 pièces), alors il n'y a pas de module I2C sur l'écran :

Et voici à quoi ressemble l'affichage avec le module I2C déjà installé :

Les broches SCL, SDA, VCC, GND sont utilisées pour Connexions Arduino. Deux contacts à gauche - sur la photo ils sont fermés par un cavalier - sont nécessaires pour que le rétroéclairage fonctionne.

Si le module n'est pas connecté, vous devrez le faire vous-même. La principale chose à laquelle il faut faire attention est de connecter les contacts dans le bon ordre. En règle générale, les premières et 16 broches sont étiquetées. Parfois, il arrive que les contacts 15-16, à travers lesquels le rétroéclairage est contrôlé, puissent être situés avant le premier (dans ce cas, ils seront numérotés). Sur le module lui-même, la première broche peut également être indiquée non pas par un chiffre, mais par un carré autour de la broche elle-même.

Schème:

Assemblons le schéma suivant :

J'attire votre attention sur les points suivants :

1. Si vous rencontrez un écran avec un module I2C déjà soudé, les fils marqués en gris ne seront pas nécessaires. Pour le reste, rien ne change.
2. Si nous ne voulons pas modifier la luminosité de l'affichage, le schéma sera simplifié:

comme vous l'avez remarqué, deux broches du module I2C étiquetées LED sont responsables du rétroéclairage de l'écran. Si nous ne voulons pas utiliser le contrôle de la luminosité, nous pouvons simplement les fermer.

Maintenant, décomposons le code.

Ici, presque tout devrait nous être familier. À la ligne 5, nous indiquons l'adresse de l'appareil. Les lignes 16 et 17 contiennent le nombre de caractères par ligne et le nombre de lignes. Dans les lignes 20-22 - Nous créons un objet pour travailler avec l'affichage et décrivons le paramètre pour travailler avec lui.

Petite parenthèse n°2 : Comment connaître l'adresse d'un périphérique I2C ?

Pour la plupart, l'adresse se trouve dans la fiche technique de la puce sur laquelle le périphérique I2C est construit. Si ce n'est pas possible, voici un lien vers une archive avec un croquis et des schémas - qui détermine les adresses de tous les appareils connectés via le bus I2C. Il vous suffit de connecter l'appareil à l'Arduino, de télécharger le croquis, d'ouvrir la console et de voir l'adresse.

Ici, nous voyons une fonction qui, en fait, s'occupera de la sortie à l'écran. Le principe de sortie ressemble à ceci :

– Nous définissons la position du début de la sortie à l'aide de la fonction setCursor()

- Imprimer la chaîne avec la fonction print()

Après cela, la prochaine fonction print() commencera la sortie à partir de la position suivante après laquelle l'entrée précédente s'est terminée. Notez également que, contrairement à la sortie vers la console, la fonction println() n'est pas utilisée ici pour terminer la sortie et le saut de ligne.

Ainsi, l'inscription «Test LCD1602» apparaîtra à l'écran sur la première ligne, et la résolution de l'affichage et un compteur indiquant le nombre de cycles que notre croquis a élaboré seront indiqués sur la deuxième ligne.

Mais, si nous devons afficher de nombreuses valeurs variables à l'écran, cette méthode n'est pas très pratique. Le fait est que la procédure d'affichage de l'affichage est très énergivore et lente, et nous effectuons la sortie dans cette fonction jusqu'à 7 fois. Il sera beaucoup plus facile de préformer la chaîne à l'avance, puis de la sortir dans son intégralité. La fonction d'entrée formatée sprintf() nous y aidera.

Note d'accompagnement #3 : La fonction d'entrée au format sprintf().

Le langage C a plusieurs fonctions très pratiques pour imprimer des chaînes - elles sont appelées fonctions de sortie formatées - printf (des mots print et format). Dans notre cas particulier nous nous intéressons à la fonction sprintf, qui n'affiche rien à l'écran, mais forme une chaîne pour une sortie ultérieure. Cela ressemble à ceci :

sprintf (str , "Chaîne %d à afficher ", i );

La fonction génère une chaîne (marquée en bleu) à l'aide d'un modèle (jaune), dans lequel les valeurs des variables (vert) sont substituées. Le résultat sera écrit dans une variable chaîne (en rouge).

Il peut y avoir plusieurs modèles et variables. Dans ce cas, les variables sont séparées par des virgules. Plus important encore, assurez-vous que le nombre de modèles dans une ligne correspond au nombre de variables. Les variables pour les modèles sont prises séquentiellement, c'est-à-dire la valeur de la première variable est remplacée dans le premier modèle, la valeur de la deuxième variable est remplacée dans le deuxième modèle, et ainsi de suite.

Que sont les modèles ? Tout motif commence par le caractère "%" et se termine par l'un des dix (dans le cas d'Arduino - sept) caractères du type. Entre eux, il peut y avoir beaucoup d'informations sur la façon d'afficher la valeur, ou il peut n'y avoir rien du tout.

Voyons ce qui peut être dans le modèle. En général, le modèle ressemble à ceci :

%[flag ][width ][.precision ]type

Les crochets indiquent que l'élément qu'ils contiennent peut être omis. La barre verticale indique que l'une des valeurs spécifiées doit être sélectionnée dans ce champ (dans notre cas, l'une des lettres H, I ou L).

Traitons d'abord l'élément requis du modèle - le type. Il spécifie quel type de variable sera généré et peut prendre l'une des valeurs suivantes :

Symbole	Sens
c	Un personnage
s	Chaîne de caractères
ré, je	Entier décimal signé
o	Entier octal
tu	Entier décimal non signé
X, X	Entier hexadécimal
p	Pointeur (hexadécimal)
F	Nombre fractionnaire au format fixe
e, e	Nombre fractionnaire au format scientifique
G, G	Nombre fractionnaire au format scientifique ou fixe

Gray a marqué les types qui ne sont pas applicables lorsque vous travaillez avec Arduino. Ainsi, pour sortir une chaîne, vous devez spécifier "%s" et sortir un entier - "%d".

Ensuite, considérez le champ de largeur. Le nombre qu'il contient indique la largeur minimale du champ dans lequel le modèle sera affiché. Si la taille de la valeur dans la variable est inférieure, le champ sera complété par des espaces ; si elle est supérieure, l'enregistrement ira au-delà du champ. Ainsi, le modèle "% 6d" pour le nombre 385 imprimera 385 (notez les trois espaces avant le nombre).

Le spécificateur de précision commence toujours par un point et le nombre qui le suit indique différentes actions selon le type de la valeur. Pour les types "d,o,u,x" il indiquera montant minimal caractères devant apparaître lors du traitement. Pour le type "f", le nombre de décimales. Pour le type "s", le nombre maximum de caractères de chaîne à imprimer. Par exemple, "%6.1f" pour le nombre 34.2345 affichera "34.1" (notez que le point est également considéré comme un signe et qu'il y aura deux espaces avant le nombre). Ou le modèle "%.3s" de la chaîne "précision" n'affichera que les trois premiers caractères - "point".

Le drapeau permet de changer l'affichage de la valeur affichée :

Vous pouvez en savoir plus sur les modèles de fonction printf sur Internet. Ici j'ai donné bref examen les fonctionnalités les plus couramment utilisées.

Ainsi, notre fonction de sortie, réécrite pour utiliser une sortie formatée, ressemblera à ceci :

Notez que dans les lignes 33 et 37, nous formons une ligne entière à sortir, et dans les lignes 34 et 38, nous les sortons.

Enfin, nos fonctions de configuration et de boucle préférées.

À la ligne 47, nous réglons la résolution d'affichage, à la ligne 48, nous allumons le rétroéclairage (dont la luminosité peut être réglée avec un potentiomètre). À la ligne 49, réglez le compteur de boucle sur zéro. Nous l'augmenterons de un à la 37e ligne lors de la sortie (rappelez-vous la construction count++ ?). Enfin, à la ligne 56, nous appelons la fonction d'affichage discutée précédemment. Tout.

Que peut-on changer ou améliorer ?

Par exemple, vous pouvez effectuer un contrôle automatique du rétroéclairage en fonction de l'éclairage à l'aide d'une photorésistance ou d'un capteur de lumière d'une station météo évoquée dans plusieurs articles précédents. Par exemple, dans une lumière forte - augmentez la luminosité du rétroéclairage et la nuit - réduisez-la. Ou vissez un capteur de mouvement et allumez le rétroéclairage lorsqu'un objet apparaît devant l'écran, ou ... En général, je pense que vous l'avez déjà compris, si vous le souhaitez, en remplaçant un ou plusieurs composants et en écrivant un morceau de code , vous pouvez sérieusement améliorer la convivialité de l'affichage. Nous pouvons également utiliser des symboles personnalisés à afficher sur l'écran.

Je ne considère pas toutes ces questions ici, car elles dépassent le cadre d'un examen pour les débutants.

Et pour aujourd'hui j'ai tout.

Avec cet article simple, je veux commencer ma série d'articles sur l'automatisation du lieu de travail.

Il existe actuellement sur le marché un grand nombre deÉcrans LCD ou, comme on les appelle aussi, écrans à synthèse de signes. 1602 affichages (16 caractères, 2 lignes) sur une puce HD44780 et compatibles. Ils peuvent être achetés à peu de frais en Chine.

Cet article décrit en détail le schéma de câblage de cet écran, mais il fonctionnera pour de nombreux autres affichages de texte. Il y a une bibliothèque pour arduino liquide Crystal avec lequel il est très pratique de travailler avec l'écran.

Composants requis

1. LCD 1602 sur puce HD44780
2. N'importe quel Arduino. Dans mon cas Arduino Nano
3. Résistance ajustable
4. disposition
5. Module de puissance
6. Fils de connexion

Connexion d'affichage

L'écran est alimenté en 5V. Le rétroéclairage de l'écran est un circuit séparé, non connecté au reste du circuit. Vous pouvez l'allumer en appliquant 5V à la broche 15 et en connectant le moins à la broche 16. Vous pouvez le rendre dimmable à l'aide d'un signal PWM. Il est également à la mode d'activer et de désactiver séparément, si nécessaire.

L'alimentation pour le reste du circuit d'affichage est fournie aux broches suivantes :

• 1-GND
• 2 - +5
• 3 - Contraste. Il est connecté via un diviseur de tension de 5V. Le diviseur est généralement une résistance variable ou d'accord conventionnelle.

Pour connecter l'écran, il suffit d'utiliser 6 lignes, 6 broches sur l'Arduino. Nous n'avons pas besoin de lire les lectures d'affichage, nous connectons donc immédiatement le 5ème contact (RW), qui est responsable de la lecture et de l'écriture à la terre.

Ensuite, nous connectons l'Arduino et le shield avec nos 6 lignes de communication. Les broches qui seront sélectionnées sur l'Arduino n'ont pas d'importance : nous les définirons dans le programme, mais pour l'exemple, la configuration suivante a été choisie :

• 4ème broche d'affichage - 4ème Broche Arduino. C'est la ligne de signal d'adresse. Appelé A0 ou RS. Selon qu'il s'agisse de 0 ou de 1, l'affichage comprend si nous avons une commande sur la ligne de données comme "déplacer le curseur" ou un code de caractère à afficher.
• La 6ème broche de l'affichage est la 5ème broche de l'Arduino. Il s'agit de la ligne d'autorisation d'accès aux données. Connu sous le nom de E ou Activer. Lorsque cette ligne devient une, l'affichage exécute une commande ou sort un caractère de la ligne de données.
• La 11e, 12e, 13e, 14e broche d'affichage est respectivement la 10e, 11e, 12e, 13e broche Arduino. Ce sont des lignes de données. Connu sous le nom de DB4, DB5, DB6, DB7.

L'écran est connecté et prêt à recevoir des données. Il reste à écrire un programme pour Arduino.

Programmation

// Inclure la bibliothèque standard LiquidCrystal #include // Initialiser l'objet écran, passer les // broches utilisées pour se connecter à l'Arduino dans l'ordre : // RS, E, DB4, DB5, DB6, DB7 LiquidCrystal lcd(4, 5, 10, 11, 12, 13); void setup() ( // définir la taille (nombre de colonnes et de lignes) de l'écran lcd.begin(16, 2); // imprimer la première ligne lcd.print("Hello World"); // définir le curseur à la colonne 0, ligne 1 Donc // c'est en fait la deuxième ligne car la numérotation commence à zéro lcd.setCursor(0, 1); // imprime la deuxième ligne lcd.print("LCD is Working!!!"); ) boucle vide() ( )

Tout est assez simple et devrait être clair à partir des commentaires.

Lors de la création de votre propre appareil, il n'est pas rare d'avoir besoin d'afficher rapidement une variété d'informations. Par exemple, si vous créez un contrôleur Maison intelligente, il est alors raisonnable d'équiper l'appareil d'un périphérique de sortie qui vous permet de connaître rapidement l'état actuel des systèmes. La meilleure solution est un écran à cristaux liquides. La consommation d'énergie avec le rétroéclairage éteint est minime et le travail avec l'écran est extrêmement simple et ne nécessite pas beaucoup d'intervention dans le code du programme. En fait, la sortie des informations sur l'écran LCD n'est pas très différente de la sortie sur le port série. L'article explique comment connecter un écran générant des caractères basé sur la populaire puce HD44780 à un contrôleur Arduino.

Fonctionnement de l'affichage de texte à cristaux liquides

Pour comprendre certaines nuances, il est utile de savoir comment fonctionne l'affichage générateur de caractères. Une caractéristique de ce type d'affichage est la présence de son propre contrôleur avec sa propre mémoire. La DDRAM est une mémoire d'affichage. Pour afficher un caractère à l'écran, vous devez charger le caractère dans une cellule mémoire, puis envoyer une commande pour afficher la cellule mémoire. Lors de la transmission, les caractères sont codés avec des codes ASCII. Par exemple, lors de l'écriture du code 0×31 dans la mémoire, le symbole « 1 ". La correspondance du code de caractère avec son affichage sur l'écran (c'est-à-dire l'"image" du caractère) est stockée dans la mémoire CGROM. CGROM n'est pas une mémoire mutable. Par conséquent, l'affichage ne peut afficher que les caractères qui sont "câblés" dans le contrôleur. C'est pourquoi tous les écrans ne sont pas capables d'afficher, par exemple, des caractères russes. Les présentoirs vendus dans notre magasin ne sont malheureusement pas russifiés. Il existe également une mémoire CGRAM. Elle est changeante. Nous pouvons créer nos propres symboles et les afficher sur l'écran. Il convient de garder à l'esprit que vous ne pouvez pas créer plus de huit personnages.

Tout ce travail "underhood" n'est important que pour comprendre certaines des nuances. Pour Arduino, il existe une bibliothèque simple et claire qui fait tout le travail pour vous, vous permettant de contrôler facilement et simplement la sortie vers l'écran.

Connecter un écran LCD à un Arduino

Pour connecter l'écran, bien sûr, vous devez l'installer sur une planche à pain. Veuillez noter : les écrans vendus dans notre magasin sont vendus sans connecteur à broches soudées. Si vous souhaitez obtenir un écran prêt à être installé sur une planche à pain tout de suite, cochez la case "souder le connecteur" sur la page du produit et nous souderons le connecteur pour vous. Le transfert de données vers l'afficheur peut être organisé de deux manières : 4 ou 8 bits à la fois. En conséquence, 4 ou 8 broches Arduino sont nécessaires. En pratique, il n'y aura pas de gain de vitesse lors de l'utilisation d'une interface huit bits. Par conséquent, nous n'avons besoin que de 4 sorties numériques pour le transfert de données. 3 autres sorties seront nécessaires pour régler le mode d'affichage. Au total, seules 7 sorties numériques du contrôleur sont nécessaires pour connecter l'écran. Les contacts à l'écran sont signés, ce qui vous permettra de ne pas vous tromper lors de la connexion :

Les conclusions sont numérotées de gauche à droite :

• 1-(VSS) Afficher le sol. Se connecte au rail au sol.
• 2-(VDD) Afficher la puissance. Se connecte au rail d'alimentation.
• 3-(VO) Entrée potentiomètre (fournie). Le contraste de l'affichage peut être réglé à l'aide du potentiomètre. La sortie centrale du potentiomètre est connectée à la sortie d'affichage.
• 4-(RS) Entrée signal "Commande". Se connecte à n'importe quelle broche numérique Arduino. Dans l'exemple, il est connecté à la broche #12.
• 5-(RW) Définit le mode "lecture" ou "écriture". Nous allons enregistrer. Nous connectons le contact au sol.
• 6-(E) Activer. Une autre sortie "commande". Lorsque la sortie est un, l'affichage exécute la commande précédemment transmise. Se connecte à n'importe quelle sortie numérique. Dans l'exemple, il est connecté à la broche #11.
• 7-10 (D0-D3) ne sont pas connectés. Ce sont les broches de données utilisées dans l'interface 8 bits. Nous n'avons pas besoin.
• 11-14 (D4-D7) Contacts pour la transmission de données en mode quatre bits. Connectez à nouveau à toutes les sorties numériques. Dans l'exemple, ils sont connectés respectivement aux broches 5, 4, 3 et 2 (D4 à la broche 5, D5 à la broche 4, etc.).
• 15 (UN) Anode LED de rétroéclairage. La résistance de limitation de courant est déjà installée dans l'affichage, de sorte que l'anode est simplement connectée au rail d'alimentation. Étant donné que le rétroéclairage utilise la LED la plus courante, vous pouvez le connecter à n'importe quelle broche qui prend en charge et contrôle la luminosité du rétroéclairage par programme.
• 16 (K) Cathode d'éclairage. Se connecte au rail au sol.

Schéma de câblage visuel :

Programmation

Ensemble avec EDI Arduino est livré avec une excellente bibliothèque pour les écrans à cristaux liquides - LiquidCrystal. La bibliothèque contient des exemples qui révèlent pleinement les capacités de l'écran. Pour commencer, utilisez l'exemple standard "HelloWorld" (Fichier -> Exemples -> LiquidCrystal -> HelloWorld) ou téléchargez le code suivant sur la carte :

/* * Broche d'affichage RS à la broche arduino 12 * Activer la broche d'affichage à la broche arduino 11 * Broche d'affichage D4 à la broche arduino 5 * Broche d'affichage D5 à la broche arduino 4 * Broche d'affichage D6 à la broche arduino 3 * Broche d'affichage D7 à la broche arduino 2 *Broche d'affichage R/W à la masse *Sortie du potentiomètre à la broche d'affichage VO */ // inclure la bibliothèque : #include ; // Initialiser l'affichage // Énumérer arduino badges auquel // RS, E, D4, D5, D6, D7 sont connectés aux broches d'affichage LCD LiquidCrystal (12, 11, 5, 4, 3, 2); void setup() ( // Spécifiez le nombre de colonnes et de lignes de l'affichage : lcd.begin(16, 2); // Affichez le message. lcd.print("hello, world!"); ) void loop() ( // place le curseur sur la colonne 0 (zéro) de la première ligne // en fait, le curseur sera placé sur la deuxième ligne (du bas) // la numérotation des lignes et des colonnes commence à zéro lcd.setCursor(0, 1 ); // affiche le nombre de secondes // écoulées depuis le chargement de la carte : lcd.print(millis()/1000); )

* Broche d'affichage RS à la broche arduino 12 * Activer la sortie d'affichage sur la broche arduino 11 * Broche d'affichage D4 à la broche arduino 5 * Broche d'affichage D5 à la broche arduino 4 * Broche d'affichage D6 à la broche arduino 3 * Broche d'affichage D7 à broche arduino 2 * L'affichage R/W mène à la terre * Sortie du potentiomètre vers la sortie d'affichage VO // inclut la bibliothèque : #comprendre ; // Initialise l'affichage // Liste les broches arduino qui sont connectées à // Broches d'affichage RS, E, D4, D5, D6, D7 void setup()( // Spécifiez le nombre de colonnes et de lignes de l'affichage : lcd . commencer (16 , 2 ) ; // Affiche le message. lcd . print("bonjour, monde!"); boucle vide ()() // la numérotation des lignes et des colonnes commence à zéro lcd . setCursor (0 , 1 ) ; // affiche le nombre de secondes, // écoulé depuis le chargement de la carte : lcd . imprimer (millis() / 1000 ) ;

Après avoir téléchargé ce code sur Carte Arduino L'écran affichera "hello, world!" Anglais "Bonjour le monde!") sur la première ligne et un chronomètre comptant les secondes sur la deuxième ligne.

Comme d'habitude, le code est simple et clair. Cependant, nous allons quand même l'analyser plus en détail :

• LCD à cristaux liquides(12, 11, 5, 4, 3, 2) - cette ligne crée un objet d'affichage avec lequel nous travaillerons à l'avenir. Entre parenthèses, les numéros des broches auxquelles les contacts d'affichage sont connectés sont passés en arguments. En conséquence : RS, E, D4, D5, D6, D7. Comme indiqué ci-dessus, les numéros de broches lors de la connexion peuvent être choisis de manière complètement arbitraire.
• lcd.begin(16, 2) - ici, nous définissons les dimensions d'affichage. Dans cet exemple, il y a 16 colonnes et 2 lignes. Pour notre écran 20X4, cette ligne ressemblerait à ceci : lcd.begin(20, 4).
• impression lcd("hello, world!") - affiche du texte. Après avoir spécifié la taille de l'affichage (lcd.begin), le curseur est placé dans le coin supérieur gauche de l'affichage. Par conséquent, ce texte sera affiché sur la première ligne (en haut) à partir de la gauche.
• lcd.setCursor(0, 1) - place le curseur à la position spécifiée. Dans ce cas, la position la plus à gauche de la deuxième ligne est spécifiée. Le numéro de la colonne est donné entre parenthèses, suivi du numéro de la ligne. Les lignes et les colonnes sont numérotées à partir de la position zéro. Ainsi : lcd.setCursor(0, 0) - place le curseur dans le coin supérieur gauche, lcd.setCursor(15, 0) - en bas à droite.
• impression lcd(millis()/1000) - déjà décrit ci-dessus. Ici, au lieu de texte, une formule de calcul est passée en paramètre. Le résultat s'affiche à l'écran.

Maintenant que nous avons traité l'exemple le plus simple, nous pouvons passer à des exemples plus complexes. Et si vous avez déjà tout compris et que vous êtes prêt à acheter un écran LCD, alors j'ai rassemblé pour vous des liens vers des vendeurs d'écrans chinois que j'ai vérifiés :

Affichages LCD de caractères

Taille d'affichage (colonnes*lignes)	Couleur d'éclairage	Statut
20*4	Bleu	vérifié
20*4	Jaune	vérifié
16*2	Bleu	vérifié
16*2	Jaune	vérifié
16*2	Vert	vérifié

Présentation d'autres exemples de la bibliothèque LiquidCrystal

Dans les exemples standards fournis avec la bibliothèque LiquidCrystal, vous pouvez trouver les croquis suivants :

• Défilement automatique- démontre la possibilité de faire défiler du texte en mode automatique. Une sorte de ligne de course. Lorsqu'un caractère est émis, les caractères précédents sont décalés. Ainsi, le nouveau caractère est sorti au même endroit.

• Cligner- démontre la possibilité d'activer l'affichage d'un curseur clignotant sous la forme d'un rectangle.

• Le curseur- démontre la possibilité d'activer l'affichage du curseur sous forme de barre horizontale clignotante.

• Caractère personnalisé- montre la possibilité de créer vos propres personnages pour les afficher sur l'écran. Au fait, il y a une erreur dans ce croquis. Détails ci-dessous.

• affichage- montre un moyen "d'éteindre" l'affichage. Autrement dit, afficher ou masquer le texte affiché.

• Faire défiler- démontre la possibilité de faire défiler du texte en mode manuel.

• affichage en série- Affiche à l'écran le texte imprimé dans la fenêtre du moniteur de port (c'est-à-dire le texte transmis via le port série).
• setCursor- remplit l'écran de lettres, démontrant la possibilité de placer le curseur sur n'importe quelle position sur l'écran.
• Direction du texte- démontre la capacité de changer la direction de la sortie du texte (de droite à gauche ou de gauche à droite).

Examinons plus en détail les procédures dont les possibilités sont démontrées par ces exemples:

lcd.autoscroll()

Après avoir appelé cette procédure, le texte à l'écran défilera automatiquement. Pour arrêter le défilement, appelez lcd.noAutoscroll().

lcd.blink()

Après l'appel de la procédure, le curseur prendra la forme d'un rectangle clignotant. Pour désactiver, appelez lcd.noBlink()

lcd.curseur()

Après l'appel de la procédure, le curseur prendra la forme d'une barre horizontale clignotante. Pour désactiver, appelez lcd.noCursor(). Le curseur redeviendra invisible.

lcd.createChar()

La procédure charge dans la table de caractères de l'écran mutable (en mémoire CGRAM) un caractère décrit comme un tableau d'octets. L'argument est le numéro du caractère et un tableau d'octets décrivant le caractère. Arrêtons-nous là-dessus plus en détail. Un maximum de huit caractères peut être stocké dans la mémoire d'affichage. Pour ajouter votre symbole, vous avez besoin de :

1. Créez un tableau d'octets décrivant un caractère.
2. Écrivez un symbole dans la mémoire d'affichage en lui attribuant un numéro dans la table des symboles. Les caractères sont numérotés de zéro à sept.
3. Afficher un caractère à l'écran à l'aide d'une procédure lcd.write()(à ne pas confondre avec lcd.print()), comme argument auquel passer le numéro du symbole.

Un bogue dans l'environnement de développement et les fonctionnalités de la bibliothèque a entraîné l'impossibilité d'afficher le caractère numéro 0 (zéro). Le compilateur rencontrera la ligne lcd.write(0) avec une erreur : " l'appel de 'write(int)' surchargé est ambigu". C'est cette ligne qui apparaît dans l'exemple Caractère personnalisé bibliothèques. Lorsque vous essayez de compiler l'exemple standard, vous obtenez une erreur :

CustomCharacter.ino : dans la fonction 'void setup()' : CustomCharacter:115 : erreur : l'appel de 'write(int)' surchargé est ambigu /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal.h:82 : note : les candidats sont : virtual size_t LiquidCrystal::write(uint8_t) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print.h:49: note: size_t Print::write(const char *)

Caractère personnalisé. ino : Dans la fonction 'void setup() ' : CustomCharacter : 115 : erreur : l'appel de 'write (int )' surchargé est ambigu /home/nazarovd/arduino-1.0.5/libraries/LiquidCrystal/LiquidCrystal. h : 82 : note : les candidats sont : virtual size_t LiquidCrystal :: write(uint8_t ) /home/nazarovd/arduino-1.0.5/hardware/arduino/cores/arduino/Print. h : 49 : note : size_t Print :: write (const char * )

Pour corriger l'erreur, modifiez simplement la ligne lcd.write( 0 ) à lcd.write( (octet)0).
Maintenant, un petit exemple de création de votre propre symbole. Affichez le symbole du rouble.

// Inclure la bibliothèque #include ; // Initialise l'affichage LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Décrire votre symbole. // Il suffit de "dessiner" le caractère avec des uns // Les unités seront remplies de points lorsqu'elles seront affichées, les zéros seront vides void setup() ( // écrivons notre personnage dans la mémoire de l'écran // comme arguments nous passons le numéro de caractère // et un tableau d'octets décrivant notre personnage lcd.createChar(0, rubl); // configure l'affichage lcd.begin (16, 2); ) void loop() ( // place le curseur dans le coin supérieur gauche de l'écran lcd.setCursor(0,0); // affiche le caractère numéro zéro sur l'écran lcd.write((byte) 0); // ne rien faire pendant 10 secondes de retard (10000); )

// Inclure la bibliothèque #comprendre ; // Initialise l'affichage LCD LiquidCrystal (12 , 11 , 5 , 4 , 3 , 2 ) ;

Cette instruction montre comment se connecter à Arduino et utiliser des écrans LCD sur 16x2 et 20x4. Ces écrans ont un rétroéclairage LED intégré à faible consommation et fonctionnent à partir de +5 V. Pour connecter ces écrans LCD, vous avez besoin de 6 broches. Vous pouvez utiliser n'importe quelles broches sur votre Arduino !

La notice est rédigée sur la base des écrans LCD Adafruit - bleu&blanc 16x2, RVB 16x2 LCD, et bleu&blanc 20x4, RVB 20x4. Si vous utilisez un écran LCD d'un autre fabricant, il n'y a aucune garantie à 100% qu'il fonctionnera (bien que dans 99% des cas cela fonctionnera).

Caractère vs LCD graphique - Quelle est la différence ?

Il existe un grand nombre d'écrans LCD différents. Dans cet article, nous examinerons les écrans LCD à caractères. Des écrans comme ceux-ci sont une excellente option pour afficher du texte. Vous pouvez également personnaliser l'affichage des icônes, mais la taille de ces icônes ne doit pas dépasser 7 pixels (tout petit !).

La photo ci-dessous montre un exemple d'écran LCD à 16 caractères avec deux lignes :

Si vous regardez attentivement, vous verrez de petits rectangles où les symboles sont affichés. Chaque rectangle est une grille de pixels distincte. À titre de comparaison, l'écran LCD graphique est illustré ci-dessous :

Sur l'affichage graphique à cristaux liquides, un grande maille pixels (dans cet exemple - 128x64). Vous pouvez afficher du texte dessus, mais il est préférable d'afficher des images. Les écrans LCD graphiques sont généralement plus grands, ont plus de broches à connecter et sont un peu plus difficiles à utiliser que les écrans LCD texte.

Dans cet article, nous ne couvrirons que les écrans de texte/caractère !

Différents modèles d'écrans LCD

Après avoir limité le type d'écrans en question, regardons ce qu'ils sont.

Bien qu'ils ne soient utilisés que pour afficher du texte, il existe différents modèles et facteurs de forme : dans le coin supérieur gauche se trouve un écran LCD 20x4 avec du texte blanc sur fond bleu, en haut à droite se trouve un 16x4 avec du texte noir sur fond vert, en le coin inférieur gauche est et 16x1 avec du texte noir sur fond gris.

La bonne nouvelle est que tous ces écrans sont interchangeables. Si vous en avez personnalisé un, vous pouvez le remplacer par un autre modèle. Le croquis devra changer un peu, mais la connexion est la même !

Dans cette partie, nous utilisons des écrans LCD avec un rail et 16 broches pour la connexion (voir photo ci-dessus). Il y a aussi un écran LCD avec 2 rails avec 8 broches pour la connexion (dans la figure ci-dessous).

La connexion du deuxième modèle à une carte de circuit imprimé sans soudure est plus difficile.

Connexion d'un écran LCD de caractères à Arduino

Installation des rails de contact

En plus de l'écran LCD, vous aurez besoin d'un cerclage supplémentaire. Premièrement - à 10 kOhm. À l'aide du potentiomètre, nous allons régler le contraste de l'affichage. Chaque écran LCD a des paramètres de contraste différents, vous ne pouvez donc pas vous passer de réglage. De plus, vous aurez besoin d'un rail à broches de 0,1".

Si le rail avec contacts est trop long, il est à la mode de simplement couper les contacts supplémentaires !

Vous devez souder les broches à l'écran LCD.

Lors de la soudure, faites extrêmement attention à ne pas endommager le vôtre ! Vous pouvez d'abord "saisir" le premier et les 16 contacts, puis souder le reste.

Alimentation et rétroéclairage

Connectez l'alimentation et l'éclairage

	Explications
	On commence à rentrer dans des trucs intéressants ! Montez votre écran LCD sur la planche à pain.
	Nous alimentons la planche à pain à partir de notre Arduino. Connectez +5V au rail rouge et Gnd au bleu.
	Après cela, nous connecterons le rétroéclairage de notre écran LCD. Connectez la broche 16 à la masse et la broche 15 au +5V. La plupart des écrans LCD ont des résistances de rétroéclairage. S'il n'y a pas de résistances sur votre module, il faudra en ajouter une entre le 5V et la broche 15. Pour calculer la valeur des résistances, cochez courant maximal pour alimenter le rétro-éclairage et la valeur approximative de la chute de tension de la fiche technique. Soustrayez la chute de tension de 5 V, puis divisez par le courant maximum et arrondissez à la valeur de résistance standard supérieure la plus proche. Par exemple, si la chute de tension est de 3,5 V et que le courant est de 16 mA, la valeur de la résistance serait : (5 - 3,5)/0,016 = 93,75 ohms, ou 100 ohms arrondis à la valeur standard. Si vous ne trouvez pas de fiche technique, utilisez une résistance de 220 ohms. Certes, dans ce cas, le rétroéclairage peut être assez pâle.
	Connectez votre Arduino à l'alimentation. Le rétroéclairage doit s'allumer.

D'ailleurs, certains écrans LCD bon marché n'ont pas de rétroéclairage !

Schéma de réglage du contraste

Circuit de contraste

	Explications
	Installez le potentiomètre. Sur la photo, il est situé à droite de la broche 1.
	Connectez un côté du potentiomètre à +5V et l'autre côté à Gnd. Connectez la broche centrale du potentiomètre à la broche 3 sur l'écran LCD.
	Maintenant, nous connectons la logique de notre écran - c'est un circuit séparé du rétroéclairage ! La broche 1 va à Gnd et la broche 2 va à + 5V.
	Allumez votre Arduino. Si l'écran LCD est rétroéclairé, il doit s'allumer. Tournez le bouton du potentiomètre pour voir le premier rectangle de pixels sur la première ligne.

Si tout a fonctionné, félicitations. Cela signifie que la logique, l'éclairage et le contraste fonctionnent ! Si cela n'a pas fonctionné, ne passez pas aux étapes suivantes de l'instruction tant que vous n'avez pas compris quelle est l'erreur !

Connexion finale

D0 à D7, RS, EN et RW. D0-D7 sont les broches qui stockent les valeurs envoyées à l'affichage. La broche RS indique au contrôleur si nous allons afficher des données (par exemple, un caractère ASCII) ou s'il s'agit d'un octet de contrôle (par exemple, changer la position du curseur). La broche EN est l'abréviation de "enable", avec cette broche, nous disons à l'écran LCD quand les données sont prêtes à être lues. La broche RW est utilisée pour définir la direction - nous voulons afficher (généralement) ou lire (moins couramment utilisées) les données de l'écran.

Toutes ces broches n'ont pas besoin d'être connectées à l'Arduino. Par exemple, il n'est pas nécessaire d'utiliser RW si nous n'affichons que des données à l'écran, il suffit donc de le "tirer" vers la broche Gnd. De plus, il est possible de communiquer avec l'écran LCD en utilisant 4 broches au lieu de 8. Une question naturelle se pose probablement, dans quels cas utilise-t-on 8 broches ? Très probablement, cela affecte le taux de transfert de données. Autrement dit, en utilisant 8 contacts au lieu de 4, vous pouvez augmenter la vitesse d'échange d'informations de 2 fois. Dans ce cas, la vitesse n'est pas importante, nous utilisons donc 4 broches pour connecter le LCD à l'Arduino.

Donc, nous avons besoin de 6 broches : RS, EN, D7, D6, D5 et D4.

Pour travailler avec l'écran LCD, nous utiliserons la bibliothèque LiquidCrystal, qui simplifie grandement le processus de configuration des broches. L'un des avantages de cette bibliothèque est que vous pouvez utiliser n'importe quelle broche de l'Arduino pour connecter les broches LCD. Ainsi, à la fin de ce guide, vous pouvez facilement changer les broches si cela est essentiel pour votre projet.

Connexion finale de l'affichage

	Explications
	Comme mentionné ci-dessus, nous n'utiliserons pas la broche RW, nous la mettons donc à la terre. C'est la broche 5.
	Après avoir connecté RS - c'est la broche n ° 4. Nous utilisons le fil marron pour le connecter à la broche numérique n ° 7 de l'Arduino.
	Avec un fil blanc, connectez la broche EN - broche #6 à la broche numérique numérique #8 sur l'Arduino.
	Le tour est venu aux contacts de données. DB7 est la broche #14 sur l'écran LCD. Il se connecte avec le fil orange à la broche n ° 12 sur l'Arduino.
	Il reste trois broches de données, DB6 (broche n°13 jaune), DB5 (broche n°12 verte) et DB4 (broche n°11 bleue). Ils se connectent respectivement aux broches #11, 10 et 9 sur l'Arduino.
	À la suite de la connexion, vous obtiendrez quelque chose de similaire à la photo de gauche.

Utilisation de l'écran LCD à caractères

Il est temps de télécharger le croquis sur l'Arduino pour contrôler l'écran LCD. La bibliothèque LiquidCrystal est installée par défaut dans l'IDE Arduino. Il nous suffit donc de télécharger l'un des exemples et d'ajuster un peu en fonction des broches que nous avons utilisées pour connecter.

Ouvrez l'esquisse File→Examples→LiquidCrystal→HelloWorld.

Mise à jour des informations sur les épingles. Recherche de la ligne suivante :

LCD LiquidCrystal (12, 11, 5, 4, 3, 2);

Et changez-le en :

Vous pouvez maintenant compiler et télécharger le croquis sur l'Arduino.

Ajustez le contraste si nécessaire.

Naturellement, vous pouvez utiliser l'écran LCD dans n'importe quelle taille. Par exemple, la photo ci-dessous montre Fonctionnement de l'écran LCD 20x4.

Ou texte noir sur fond vert :

L'un des avantages des écrans avec du texte noir sur fond vert est la possibilité de désactiver le rétroéclairage.

Nous utilisons combien de lignes

Voyons comment l'écran LCD gère les longs messages et utilise plusieurs lignes. Par exemple, si vous modifiez la ligne suivante :

lcd.print("bonjour, monde!");

Pour le prochain :

lcd.print("bonjour, tout le monde ! c'est un long long message");

affichage LCD 16x2 tronquera tout après le 16e caractère :

Mais un écran LCD 20x4 portera les caractères non affichés de la première ligne à la troisième (la deuxième ligne continuera sur la quatrième). Pas très pratique, mais à ce stade, il faut s'en accommoder. Ainsi lors de l'affichage de chaînes longues, comptez les caractères afin de ne pas dépasser la longueur autorisée.

LCD avec rétroéclairage RVB

Ces écrans fonctionnent comme des écrans normaux, mais ils ont trois LED (rouge, verte, bleue) pour le rétroéclairage, vous pouvez donc utiliser différentes couleurs de rétroéclairage.

Après avoir connecté l'écran LCD et l'avoir vérifié conformément aux instructions ci-dessus, connectez les LED aux broches analogiques PWM de votre Arduino pour affiner la couleur. Si vous utilisez Arduino Uno, il devrait vous rester trois broches PWM libres. connecter la LED rouge (broche 16 sur LCD) à Digital 3, DEL verte(broche 17) à Digital 5, et la LED bleue (broche 18 sur l'écran LCD) à digital 6. Le module LCD a déjà des résistances, vous n'avez donc pas besoin d'en connecter d'autres.

Téléchargez maintenant le croquis ci-dessous sur l'Arduino.

// inclut les librairies dans le sketch :

#comprendre

#comprendre

#définir REDLITE 3

#définir GREENLITE 5

#définir BLUELITE 6

// déclarer le nombre de contacts que nous utilisons

// pour le transfert de données

LCD LiquidCrystal (7, 8, 9, 10, 11, 12);

// la luminosité peut être modifiée dans la plage 0 -> 255

luminosité int = 255 ;

// définit le nombre de colonnes et de lignes sur l'écran LCD :

lcd.begin(16, 2);

// affiche le message sur l'écran LCD.

lcd.print("Affichage RVB 16x2");

lcd.setCursor(0,1);

lcd.print("LCD multicolore");

pinMode(REDLITE, SORTIE);

pinMode(GREENLITE, SORTIE);

pinMode(BLUELITE, SORTIE);

luminosité = 100 ;

pour (int je = 0; je< 255; i++) {

setBacklight(i, 0, 255-i);

pour (int je = 0; je< 255; i++) {

setBacklight(255-i, i, 0);

pour (int je = 0; je< 255; i++) {

setBacklight(0, 255-i, i);

void setBacklight(uint8_t r, uint8_t g, uint8_t b) (

// configurez la LED rouge - elle est plus lumineuse que les autres !

r = carte(r, 0, 255, 0, 100);

g = carte(g, 0, 255, 0, 150);

r = map(r, 0, 255, 0, luminosité);

g = map(g, 0, 255, 0, luminosité);

b = map(b, 0, 255, 0, luminosité);

// anode commune, donc inversez !

r = carte(r, 0, 255, 255, 0);

g = carte(g, 0, 255, 255, 0);

b = carte(b, 0, 255, 255, 0);

Serial.print("R = "); Serial.print(r, DEC);

Serial.print(" G = "); Serial.print(g, DEC);

Serial.print(" B = "); Serial.println(b, DEC);

analogWrite(REDLITE, r);

analogWrite(GREENLITE, g);

analogWrite(BLUELITE, b);

Le résultat de ce croquis est montré dans la vidéo ci-dessous.

commande createChar

Vous souhaiterez probablement utiliser des caractères spéciaux. Par exemple, si vous développez un projet utilisant un capteur de température (), vous aurez besoin du symbole (°).

Cela peut être fait en utilisant la commande createChar. De plus, vous pourriez trouver un excellent site Web qui fait tout le sale boulot de créer de nouveaux symboles pour vous !

Laissez vos commentaires, questions et partagez expérience personnelle dessous. Dans la discussion, de nouvelles idées et projets naissent souvent !

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

#	Contacts	A quoi sert	Noter
1	VSS (VSS)	TERRE. Terre. Afficher l'alimentation du microcontrôleur.	0V
2	VDD (VCC)	Tension d'alimentation pour le microcontrôleur d'affichage.	+5V
3	V0 (VEE)	Contraste des caractères à l'écran. Il est préférable de se connecter via un potentiomètre.	de 0v à +5V
4	RS (RS)	Enregistrez la sélection.
5	RW (R/W)	Commutation du mode lecture/écriture. Glissons-le au sol, nous n'avons qu'à transmettre des informations à l'écran.	0-écriture + 5V-lecture
6	E	Pointage
7	D0 (DB0)		Données
8	D1 (DB1)	Transfert de données. (Ne pas utiliser)	Données
9	D2 (DB2)	Transfert de données. (Ne pas utiliser)	Données
10	D3 (DB3)	Transfert de données. (Ne pas utiliser)	Données
11	D4 (DB4)		Données
12	D5 (DB5)	Transfert de données. (Engagé)	Données
13	D6 (DB6)	Transfert de données. (Engagé)	Données
14	D7 (DB7)	Transfert de données. (Engagé)	Données
15	A (DEL+)	Tension + 5V, rétroéclairage de l'écran, la luminosité de l'écran peut être ajustée via un potentiomètre.	+5V
16	K(DEL-)	GND Masse, rétroéclairage de l'affichage	0V

v

Le transfert de données vers l'afficheur est possible en deux versions : 8 et 4 bits par cycle. Car 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 la connexion physique de l'écran. En cliquant dessus, il s'ouvre en 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 une variable de type LiquidCrystal Et déterminer à travers quels contacts l'Arduino fonctionne avec l'affichage. 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, 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 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); // Tension d'alimentation du rétroéclairage de l'écran. ) 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()); // affiche le temps d'exécution actuel if (x< millis()) // если время работы выключения наступило >( digitalWrite (screenLed, LOW); // puis éteint l'affichage ) )

Et le résultat :