Como usar o método LCD CreateChar em Arduino

Os caracteres em Arduino incluem os alfanuméricos e todos os símbolos que podem ser usados ​​para a representação dos dados de entrada e saída ou podem ser usados ​​para executar diferentes funções. O uso de caracteres pode ser benéfico ao exibir as informações de um programa, pois facilita a interpretação das informações. Da mesma forma, para organizar os dados que os caracteres também são usados ​​e existem algumas funções usadas para definir caracteres no programa Arduino. Este discurso explica a função usada para criar caracteres personalizados em detalhes.

Como usar a função createChar () para criar caracteres

Em Arduino, há uma função especial através da qual os personagens também podem ser feitos. Esta função também pode ser usada para fazer formas diferentes, símbolos diferentes e algumas animações também.

Para criar caracteres, essa função requer os dois argumentos. O primeiro é o número do personagem que é usado quando o personagem deve ser exibido.

O segundo argumento são os dados do personagem que deve ser exibido; Pode ser na forma de números binários ou hexadec pelaula.

LCD.createChar (número, dados de caracteres);

Os caracteres personalizados podem ser criados ligando e desligando algumas partes do LCD. Por exemplo, se considerarmos um LCD 16 × 2 cada célula da tela, é dividido em pontos com 8 linhas e 5 colunas.

Portanto, cada célula tem 40 pixels e essa função createChar () pode usar 8 bits dos dados ao mesmo tempo. Se os dados forem mais de 8 bits, podemos declarar vários caracteres e chamá-los por números para cada célula e exibir essa célula em uma ordem específica.

Por exemplo, se tivermos que exibir a seta para baixo, temos que dar o valor de um ao respectivo ponto que deve ser ativado. Da mesma forma, no estado off -estado, o valor de cada ponto será zero, para que possamos dizer que, por padrão, cada linha tem um binário de 0. Portanto, para exibir a seta, podemos declarar os seguintes binários usando o tipo de dados de bytes e também podemos escrever caracteres personalizados usando seus valores hexadecimais usando o mesmo tipo de dados de byte.

// valores binários
Arrow de byte char [8] = 0B00000,0B00000.0B00100.0B00100.0B10101.0B01110.0B00100.0B00000;
// valores hexadecimais
BYTE CustomChar [] = 0x00,0x00,0x04,0x04,0x15,0x0e, 0x04,0x00;

Abaixo, demos a tabela em que a representa as colunas, enquanto o B representa as linhas, para que cada ponto tenha um valor de 0 ou 1. Nesse caso, desenhamos uma seta descendente e, para isso, ligamos alguns pontos, dando -lhes o valor de 1. A linha B3 tem apenas um ponto que deve ser girado, para que tenha o valor de 1 e esse ponto esteja na coluna A2 e o resto da tabela é organizado dessa maneira.

	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

Como nas duas primeiras linhas e a última linha da célula, não há ponto que esteja no estado no estado, de modo que os binários dessas linhas serão zero. Portanto, os valores para essas linhas também serão incluídos ao declarar o personagem e também podemos usar os hexadecimais para criar um personagem.

Também podemos exibir vários caracteres usando o LCD.createChar () função várias vezes. Então podemos exibir cada caractere usando o LCD.escrever() função dando o número atribuído ao personagem.

Fornecemos o código Arduino para usar o LCD.createChar () função em que exibimos vários caracteres. Para exibir os caracteres que temos para alocar o local específico para cada caractere em caso de vários caracteres usando o LCD.setCursor () função.

Código Arduino para criar caracteres personalizados

#include // Definindo Biblioteca para LCD
LiquidCrystal LCD (12, 11, 5, 4, 3, 2); // pinos Arduino para LCD
// declarando os binários para cada personagem
BYTE CHAR1 [8] = 0B00000,0B00000.0B00100.0B00100.0B10101.0B01110.0B00100.0B00000;
byte char2 [8] = 0b00000,0b00000.0b00100,0b01010,0b11011,0b0101010,0b111111,0b00000;
byte char3 [8] = 0b00000,0b00000,0b01010,0b10101,0b10001,0b0101010.0b00100,0b00000;
Void Setup ()
Serial.começar (9600);
LCD.começar (16, 2); // inicializando as dimensões do LCD
LCD.createChar (1, char1); // Criando o primeiro personagem
LCD.createChar (2, char2); // Criando o segundo personagem
LCD.createChar (3, char3); // Criando o terceiro personagem
LCD.setCursor (1, 0); // Localizar para o primeiro personagem
LCD.Escreva ((byte) 1); // imprimindo o personagem usando o número dado a ele
LCD.setCursor (2, 0); // coloque para o segundo personagem
LCD.Escreva ((byte) 2); // imprimindo o personagem usando o número dado a ele
LCD.setCursor (3, 0); // coloque para o terceiro caractere
LCD.Escreva ((byte) 3); // imprimindo o personagem usando o número dado a ele

Void Loop ()

No código Arduino após definir a biblioteca para LCD e atribuir os pinos de Arduino para LCD os binários de três caracteres são definidos.

Então na função de configuração depois de declarar as dimensões do LCD a função LCD.createChar () é usado para criar o personagem personalizado. Os binários definidos dos caracteres são dados a essa função e cada caractere é atribuído um número que é usado no LCD.imprimir() função. Para cada personagem a função LCD.createChar () é usado separadamente.

O esquema para o circuito é:

Saída

Conclusão

O uso de caracteres na programação pode ajudar na rotulagem dos dados exibidos, como a exibição do símbolo do termômetro para a temperatura. Para criar e exibir os caracteres personalizados especiais no módulo de exibição, a função LCD.createChar () pode ser usado. Este artigo explica como criar caracteres especiais usando o LCD.função createChar ().