Comment utiliser la méthode CreateChar LCD dans Arduino
Comment utiliser la fonction CreateChar () pour créer des caractères
Dans Arduino, il existe une fonction spéciale à travers laquelle les caractères peuvent également être fabriqués. Cette fonction peut également être utilisée pour fabriquer différentes formes, différents symboles et certaines animations également.
Pour créer des caractères, cette fonction nécessite les deux arguments. Le premier est le numéro du caractère qui est utilisé lorsque le caractère doit être affiché.
Le deuxième argument est les données du caractère qui doivent être affichées; il peut être sous la forme de nombres binaires ou de nombres hexadécimaux.
LCD.createChar (nombre, données de caractère);
Les caractères personnalisés peuvent être créés en activant et en éteignant certaines parties de l'écran LCD. Par exemple, si nous considérons un LCD 16 × 2, chaque cellule de l'écran est divisée en points ayant 8 lignes et 5 colonnes.
Ainsi, chaque cellule est de 40 pixels et cette fonction CreateChar () peut utiliser 8 bits des données en même temps. Si les données sont supérieures à 8 bits, nous pouvons déclarer plusieurs caractères et les appeler par des chiffres pour chaque cellule et afficher cette cellule dans un ordre spécifique.
Par exemple, si nous devons afficher la flèche vers le bas, nous devons donner la valeur de celui au point respectif qui doit être allumé. De même, à l'état hors de l'état, la valeur de chaque point sera nulle afin que nous puissions dire que par défaut, chaque ligne a un binaire de 0. Ainsi, pour afficher la flèche, nous pouvons déclarer les binaires suivants en utilisant le type de données d'octets et nous pouvons également écrire des caractères personnalisés en utilisant ses valeurs hexadécimales en utilisant le même type de données d'octets.
// valeurs binaires
Byte Arrow char [8] = 0b00000,0b00000,0b00100,0b00100,0b10101,0b01110,0b00100,0b00000;
// valeurs hex
Byte CustomChar [] = 0x00,0x00,0x04,0x04,0x15,0x0e, 0x04,0x00;
Ci-dessous, nous avons donné le tableau dans lequel A représente les colonnes tandis que le B représente les lignes afin que chaque point ait soit une valeur de 0 ou 1. Dans ce cas, nous avons dessiné une flèche vers le bas et pour cela, nous avons allumé certains points en leur donnant la valeur de 1. La ligne B3 n'a qu'un seul point qui doit être retourné, donc il a la valeur de 1 et ce point réside dans la colonne A2 et le reste du tableau est organisé de cette manière.
| A4 | A3 | A2 | A1 | A0 | |
| B0 | 0 | 0 | 0 | 0 | 0 |
| B1 | 0 | 0 | 0 | 0 | 0 |
| B2 | 0 | 0 | 1 | 0 | 0 |
| B3 | 0 | 0 | 1 | 0 | 0 |
| B4 | 1 | 0 | 1 | 0 | 1 |
| B5 | 0 | 1 | 1 | 1 | 0 |
| B6 | 0 | 0 | 1 | 0 | 0 |
| B7 | 0 | 0 | 0 | 0 | 0 |
Étant donné que dans les deux premières lignes et la dernière rangée de la cellule, il n'y a pas de point qui est à l'état, donc les binaires de ces lignes seront nuls. Ainsi, les valeurs de ces lignes seront également incluses lors de la déclaration du caractère et nous pouvons également utiliser les hexadécimaux pour créer un personnage.
Nous pouvons également afficher plusieurs caractères en utilisant le LCD.createChar () fonction plusieurs fois. Ensuite, nous pouvons afficher chaque caractère en utilisant le LCD.écrire() fonction en donnant le numéro attribué au caractère.
Nous avons fourni le code Arduino pour utiliser le LCD.createChar () fonction dans laquelle nous avons affiché plusieurs caractères. Pour afficher les caractères, nous devons attribuer la place spécifique pour chaque caractère en cas de plusieurs caractères en utilisant le LCD.setCursor () fonction.
Code Arduino pour créer des caractères personnalisés
#include // Définition de la bibliothèque pour l'écran LCD
LCD LiquidCrystal (12, 11, 5, 4, 3, 2); // épingles Arduino pour LCD
// déclarant les binaires pour chaque personnage
octet char1 [8] = 0b00000,0b00000,0b00100,0b00100,0b10101,0b01110,0b00100,0b00000;
octet char2 [8] = 0b00000,0b00000,0b00100,0b010,0b11011,0b01010,0b11111,0b00000;
octet char3 [8] = 0b00000,0b00000,0b01010,0b10101,0b10001,0b01010,0b00100,0b00000;
void setup()
En série.commencer (9600);
LCD.commencer (16, 2); // initialisation des dimensions de l'écran LCD
LCD.CreateChar (1, char1); // Création du premier personnage
LCD.CreateChar (2, char2); // Création du deuxième caractère
LCD.CreateChar (3, char3); // Création du troisième caractère
LCD.setCursor (1, 0); // place pour le premier caractère
LCD.écrire ((octet) 1); // imprimer le caractère en utilisant le nombre qui lui est donné
LCD.setCursor (2, 0); // place pour le deuxième caractère
LCD.écrire ((octet) 2); // imprimer le caractère en utilisant le nombre qui lui est donné
LCD.setCursor (3, 0); // place pour le troisième caractère
LCD.écrire ((octet) 3); // imprimer le caractère en utilisant le nombre qui lui est donné
VOID LOOP ()
Dans le code Arduino après avoir défini la bibliothèque pour l'écran LCD et l'attribution des épingles d'Arduino à l'écran LCD, les binaires pour trois caractères sont définis.
Puis dans la fonction de configuration après avoir déclaré les dimensions de l'écran LCD, la fonction LCD.createChar () est utilisé pour créer le caractère personnalisé. Les binaires définis des caractères sont donnés à cette fonction et chaque caractère se voit attribuer un nombre qui est utilisé dans le LCD.imprimer() fonction. Pour chaque caractère, la fonction LCD.createChar () est utilisé séparément.
Le schéma du circuit est:
Sortir
Conclusion
L'utilisation de caractères dans la programmation peut aider à étiqueter les données affichées comme afficher le symbole du thermomètre pour la température. Pour créer et afficher les caractères personnalisés spéciaux dans le module d'affichage, la fonction LCD.CreateChar () peut être utilisé. Cet article explique comment créer des caractères spéciaux en utilisant l'écran LCD.Fonction CreateChar ().