Todo radioamador, após uma certa quantidade de projetos simples e caseiros, chega ao objetivo de construir algo grandioso a partir de sensores e botões. Afinal, é muito mais interessante exibir dados em um display do que em um monitor de porta. Mas aí surge a pergunta: qual display escolher? E em geral, como conectar, o que é necessário para conectar? As respostas a essas perguntas serão discutidas neste artigo.
LCD 1602
Entre as muitas opções de exibição, gostaria de mencionar especificamente a tela LCD1602 baseada no controlador HD4478. Este display está disponível em duas cores: letras brancas sobre fundo azul, letras pretas sobre fundo amarelo. Conectar o LCD 1602 ao Arduino também não causará problemas, pois há uma biblioteca embutida e não há necessidade de baixar nada adicional. Os displays diferem não apenas no preço, mas também no tamanho. Muitas vezes, os rádios amadores usam 16 x 2, ou seja, 2 linhas de 16 caracteres. Mas também existe 20 x 4, onde existem 4 linhas de 20 caracteres. As dimensões e a cor não desempenham nenhum papel na conexão do display LCD 1602 ao Arduno; O ângulo de visão é de 35 graus, o tempo de resposta da tela é de 250 ms. Pode funcionar em temperaturas de -20 a 70 graus Celsius. Durante a operação, utiliza 4 mA para a tela e 120 mA para a luz de fundo.
Onde é usado?
Este display é popular não apenas entre rádios amadores, mas também entre grandes fabricantes. Por exemplo, impressoras e máquinas de café também usam LCD1602. Isso se deve ao seu baixo preço; esse display custa de 200 a 300 rublos em sites chineses. Vale a pena comprar lá, pois em nossas lojas os markups para esse display são muito altos.
Conectando ao Arduino
Conectar o LCD 1602 ao Arduino Nano e Uno não é diferente. Você pode trabalhar com o display em dois modos: 4 bits e 8. Ao trabalhar com 8 bits, são usados os bits de ordem inferior e superior, e com 4 bits, apenas os de ordem inferior. Não adianta trabalhar com 8 bits, pois irá adicionar mais 4 contatos para conexão, o que não é aconselhável, pois a velocidade não será maior, o limite para atualizações do display é de 10 vezes por segundo. Em geral, para conectar o lcd 1602 ao Arduino são utilizados muitos fios, o que causa alguns transtornos, mas existem blindagens especiais, mas falaremos mais sobre isso depois. A foto mostra a conexão do display ao Arduino Uno:
Código de exemplo:
#incluir
O que o código faz? O primeiro passo é conectar a biblioteca para trabalhar com o display. Conforme mencionado acima, esta biblioteca já está incluída no IDE do Arduino e não precisa ser baixada e instalada adicionalmente. A seguir são determinados os contatos que estão conectados aos pinos: RS, E, DB4, DB5, DB6, DB7, respectivamente. Em seguida, o tamanho da tela é definido. Como estamos trabalhando com uma versão com 16 caracteres e 2 linhas, escrevemos os seguintes valores. Colocamos o cursor no início da primeira linha e exibimos nosso primeiro texto Hello World. A seguir, coloque o cursor na segunda linha e exiba o nome do site. É isso! Foi considerada a conexão do lcd 1602 ao Arduino Uno.
O que é I2C e por que é necessário?
Conforme mencionado acima, conectar o display requer muitos contatos. Por exemplo, ao trabalhar com vários sensores e um display LCD, 1.602 pinos podem simplesmente não ser suficientes. Muitas vezes, os rádios amadores utilizam as versões Uno ou Nano, que não possuem muitos contatos. Então as pessoas criaram escudos especiais. Por exemplo, I2C. Ele permite conectar um display com apenas 4 pinos. Isso é o dobro. O módulo I2C é vendido separadamente, onde você mesmo precisa soldá-lo, e já soldado ao display LCD 1602.
Conexão usando módulo I2C
Conectar o LCD 1602 ao Arduino Nano com I2C ocupa pouco espaço, apenas 4 pinos: terra, alimentação e 2 saídas de dados. Conectamos alimentação e aterramento a 5V e GND no Arduino, respectivamente. Conectamos os dois contatos restantes: SCL e SDA a quaisquer pinos analógicos. Na foto você pode ver um exemplo de conexão de um lcd 1602 a um arduino com módulo I2C:
Código do programa
Se para trabalhar com um display sem módulo era necessário utilizar apenas uma biblioteca, então para trabalhar com módulo são necessárias duas bibliotecas. Um deles já está incluso no Arduino IDE - Wire. Outra biblioteca, LiquidCrystal I2C, deve ser baixada e instalada separadamente. Para instalar a biblioteca no Arduino, o conteúdo do arquivo baixado deve ser carregado na pasta raiz Bibliotecas. Exemplo de código de programa usando I2C:
#incluir
Como você pode ver, o código é quase o mesmo.
Como adicionar seu próprio símbolo?
O problema com essas telas é que não há suporte para o alfabeto e símbolos cirílicos. Por exemplo, você precisa carregar algum símbolo no display para que ele possa refleti-lo. Para fazer isso, o display permite criar até 7 de seus próprios símbolos. Imagine a mesa:
| 0 | 0 | 0 | 1 | 0 |
| 0 | 0 | 0 | 0 | 1 |
| 1 | 1 | 0 | 0 | 1 |
| 0 | 0 | 0 | 0 | 1 |
| 1 | 1 | 0 | 0 | 1 |
| 0 | 0 | 0 | 0 | 1 |
| 0 | 0 | 0 | 1 | 0 |
| 0 | 0 | 0 | 0 | 0 |
Se 0 - não há nada lá, se 1 - esta é uma área pintada. No exemplo acima você pode ver a criação do símbolo “smiley sorridente”. Usando um programa de exemplo no Arduino ficaria assim:
#incluir
Como você pode ver, uma máscara de bits foi criada igual à tabela. Uma vez criado, ele pode ser exibido como uma variável no display. Lembre-se de que você só pode armazenar 7 caracteres na memória. Em princípio, isso é suficiente. Por exemplo, se você precisar mostrar um símbolo de grau.
Problemas em que a tela pode não funcionar
Há momentos em que a tela não funciona. Por exemplo, liga, mas não mostra caracteres. Ou não liga de jeito nenhum. Primeiro, verifique se você conectou os pinos corretamente. Se você usou uma conexão LCD 1202 com Arduino sem I2C, é muito fácil se enroscar nos fios, o que pode fazer com que o display não funcione corretamente. Você também deve certificar-se de que o contraste do display seja aumentado, pois com o contraste mínimo nem é visível se o LCD 1602 está ligado ou não. Se isso não ajudar, talvez o problema esteja na soldagem dos contatos, isto é, ao usar um módulo I2C. Outro motivo comum pelo qual o display pode não funcionar é a configuração incorreta do endereço I2C. O fato é que existem muitos fabricantes, e eles podem colocar um endereço diferente, você precisa corrigir aqui:
LiquidCrystal_I2Clcd(0x27,16,2);
Entre parênteses você pode ver dois valores, 0x27 e 16,2 (16,2 é o tamanho da tela e 0x27 é o endereço I2C). Em vez desses valores, você pode tentar definir 0x37 ou 0x3F. Bem, outro motivo é simplesmente um LCD 1602 com defeito. Considerando que quase tudo para Arduino é fabricado na China, você não pode ter 100% de certeza de que o produto adquirido não está com defeito.
Prós e contras do LCD 1602
Vejamos os prós e os contras do display LCD 1602.
- Preço. Este módulo pode ser adquirido a um preço bastante razoável nas lojas chinesas. O preço é de 200 a 300 rublos. Às vezes é até vendido junto com um módulo I2C.
- Fácil de conectar. Provavelmente ninguém está conectando o LCD 1602 sem I2C atualmente. E com este módulo a conexão leva apenas 4 contatos, não haverá “teias” de fios.
- Programação. Graças às bibliotecas prontas, trabalhar com este módulo é fácil; todas as funções já estão escritas; E se você precisar adicionar seu próprio símbolo, isso levará apenas alguns minutos.
- Durante a sua utilização por milhares de rádios amadores, não foram identificadas grandes desvantagens, apenas há casos de compras defeituosas, uma vez que são utilizadas principalmente versões chinesas de displays.
Este artigo analisou a conexão do 1602 ao Arduino e também forneceu exemplos de programas para trabalhar com este monitor. É realmente um dos melhores em sua categoria; não é à toa que milhares de radioamadores o escolhem para seus projetos!
Os monitores LCD de 1602 dimensões, baseados no controlador HD44780, são um dos monitores mais simples, acessíveis e populares para o desenvolvimento de diversos dispositivos eletrônicos. Pode ser encontrado tanto em aparelhos montados no joelho, quanto em aparelhos industriais, como, por exemplo, máquinas de café. Os módulos e escudos mais populares com o tema Arduino, como e, são coletados com base neste display.
Neste artigo, mostraremos como conectá-lo ao Arduino e exibir informações.
Componentes usados (comprar na China):
. Painel de controle
. Conectando fios
Esses displays possuem dois designs: retroiluminação amarela com letras pretas ou, o que é mais comum, retroiluminação azul com letras brancas.
O tamanho dos monitores no controlador HD44780 pode ser diferente, mas serão controlados da mesma maneira. As dimensões mais comuns são 16x02 (ou seja, 16 caracteres em duas linhas) ou 20x04. A resolução dos próprios símbolos é de 5x8 pixels.
A maioria dos monitores não suporta o alfabeto cirílico; apenas os monitores marcados como CTK o possuem. Mas podemos tentar resolver parcialmente este problema (continua no artigo).
Saídas de exibição:
O display possui um conector de 16 pinos para conexão. Os pinos estão marcados na parte de trás da placa.
1 (VSS) - Fonte de alimentação do controlador (-)
2 (VDD) - Fonte de alimentação do controlador (+)
3 (VO) - Pino de controle de contraste
4 (RS) - Seleção de registro
5 (R/W) - Leitura/Escrita (modo de gravação quando conectado ao terra)
6 (E) - Ativar (estroboscópio em declínio)
7-10 (DB0-DB3) – Bits de ordem inferior da interface de 8 bits
11-14 (DB4-DB7) – Bits de alta ordem da interface
15 (A) - Fonte de alimentação de retroiluminação do ânodo (+)
16 (K) - Fonte de alimentação de retroiluminação cátodo (-)
Modo de autoteste:
Antes de tentar conectar e enviar informações, seria uma boa ideia saber se o monitor está funcionando ou não. Para fazer isso, você precisa aplicar tensão ao próprio controlador ( VSS e VDD), ligue a luz de fundo ( A e K) e também ajuste o contraste.
Para ajustar o contraste, use um potenciômetro de 10 kOhm. Não importa qual será a forma. +5V e GND são fornecidos às pernas externas, a perna central é conectada à saída VO
Após aplicar energia ao circuito, é necessário obter o contraste correto; se não estiver configurado corretamente, nada será exibido na tela; Para ajustar o contraste, você deve brincar com o potenciômetro.
Se o circuito estiver montado corretamente e o contraste ajustado corretamente, a linha superior deverá ser preenchida com retângulos na tela.
Saída de informações:
A biblioteca LiquidCrystal.h incorporada ao Arduino IDE é usada para operar o display.
Funcionalidade da biblioteca
//Trabalhando com o cursor lcd.setCursor(0, 0); // Define o cursor (número da célula, linha) lcd.home(); // Coloca o cursor em zero (0, 0) lcd.cursor(); //Ativa a visibilidade do cursor (sublinhado) lcd.noCursor(); //Remove a visibilidade do cursor (sublinhado) lcd.blink(); //Ativa o cursor piscando (cursor 5x8) lcd.noBlink(); //Desliga o cursor piscando (cursor 5x8) //Informações de saída lcd.print("site"); // Informações de saída lcd.claro(); // Limpa o display, (exclui todos os dados) coloca o cursor em zero lcd.rightToLeft(); //A gravação é feita da direita para a esquerda lcd.leftToRight(); // A escrita é feita da esquerda para a direita lcd.scrollDisplayRight(); // Desloca tudo no display um caractere para a direita lcd.scrollDisplayLeft(); // Desloca tudo no display um caractere para a esquerda //Informações úteis para espiões :) lcd.noDisplay(); // As informações no display ficam invisíveis, os dados não são apagados // se, no momento em que esta função está ativa, nada for exibido, então lcd.display(); // Ao chamar a função display(), todas as informações que foram restauradas anteriormente são restauradas no display.
O próprio display pode operar em dois modos:
Modo de 8 bits - bits baixos e altos são usados para isso (BB0-DB7)
Modo de 4 bits - apenas os bits menos significativos são usados para isso (BB4-DB7)
Não é aconselhável usar o modo de 8 bits nesta tela. Seu funcionamento requer mais 4 pernas, e praticamente não há ganho de velocidade porque A taxa de atualização desta tela é limitada< 10раз в секунду.
Para gerar texto, você precisa conectar os pinos RS, E, DB4, DB5, DB6, DB7 aos pinos do controlador. Eles podem ser conectados a qualquer pino do Arduino, o principal é definir a sequência correta no código.
Código de exemplo:
#incluir
lcd.print("site"); // Texto de saída) void
laço
Crie seus próprios símbolos
Classificamos a saída de texto, as letras do alfabeto inglês estão conectadas à memória do controlador dentro do display e não há problemas com elas. Mas o que fazer se o símbolo requerido não estiver na memória do controlador?
Não tem problema, o símbolo necessário pode ser criado manualmente (até 7 símbolos no total). A célula nos monitores que estamos considerando tem uma resolução de 5x8 pixels. Tudo o que a tarefa de criar um símbolo se resume a escrever uma máscara de bits e colocar uns nos lugares onde os pontos deveriam estar acesos e zeros onde não deveriam.
No exemplo abaixo desenharemos uma carinha sorridente.#incluir
// Exibe uma carinha sorridente (caractere número 1) - "\1"
) vazio
- Bônus
Nos comentários, um membro da comunidade enviou um link para o gerador de símbolos
Igorka
Diagrama de conexão do indicador
Diagrama esquemático de conexão do display LCD ao MK
Desenhei um diagrama de conexão. Para alimentar o display você precisa de uma voltagem de 3,3V. Se você alimentar o microcontrolador com 5 V, instale divisores de resistor e um microcircuito 78L33. Se todo o circuito for alimentado por 3,3 V, não serão necessários divisores de resistor. Parece que o Atmega8A pode operar a partir de 3,3V desde que a frequência não seja superior a 8 MHz. Pessoalmente, não tentei. Tenho tudo montado em uma placa de depuração alimentada por 5V. Em nenhum caso você deve colocar um eletrólito de grande capacidade na frente do próprio display. Logo no início da operação, o controlador envia comandos de inicialização para o display. Leva tempo para carregar o capacitor. Enquanto estiver carregando e o display começar a funcionar, algum tempo passará e ele não receberá um comando de inicialização. Claro, são milissegundos, mas neste caso o efeito é perceptível.
Exibir diagrama de pinagem
O display do Nokia 1202 possui uma interface SPI de 9 bits. O microcontrolador que escolhemos não tem esse luxo. Portanto, para nos comunicarmos com o display, não usamos hardware, mas software SPI, por assim dizer, “acéfalo”. Não vou te dizer como criar novos projetos no CodeVision - pense por si mesmo, só direi isso. todos os pinos PORTB devem ser configurados como saída Nas configurações do projeto você precisa marcar ". Armazene constantes globais na memória FLASH" Esta ação é necessária para que os arrays de fontes e nossas imagens sejam armazenados em flash.
Então, criamos o projeto. Escolhemos um microcontrolador, ajustamos a frequência do clock e configuramos o projeto. O que vem a seguir? E então você precisa adicionar bibliotecas para trabalhar com as bibliotecas de exibição e atraso. Descompacte o arquivo. Existem dois arquivos lá. Eles precisam ser copiados para pastas específicas. Espero que você tenha instalado o CodeVision diretamente na unidade C:\. Se sim, copie os arquivos para os caminhos apropriados:
C:\cvavreval\inc para o arquivo 1100.inc e
C:\cvavreval\lib para arquivo 1100.h .
Também quero dizer que a atribuição dos pinos do microcontrolador pode ser alterada no arquivo 1100h. Então o diagrama de conexão mudará. Vamos começar a codificar. Vamos apenas exibir alguma inscrição no display na fonte principal 5*8. No início adicionaremos bibliotecas.
#incluir< 1100.h>//exibe biblioteca
#incluir
Bem na parte inferior, antes do loop while(1)() principal, inicializamos a exibição e a limpamos.
lcd_init(); //mostra a inicialização
lcd_clear(); //limpa a tela
Também colocaremos nossa inscrição antes do ciclo principal. Deixe o controlador primeiro exibir a mensagem no display e depois girar no loop principal. Escrevemos isto:
print_string("Produza a inscrição",5,0);
print_string("O que quisermos",0,1);
print_string("BUCKER",10,2);
Acho que está tudo claro aqui. O primeiro dígito é a coordenada x no display. Pode assumir um valor de 0 a 96. O segundo é uma string. É de 0 a 7. A princípio cabem 8 linhas e meia ali, mas não vamos ler meia linha. Nós compilamos e atualizamos. Vejamos o resultado. Você também pode instalar o Proteus e testá-lo. O controlador pode ser configurado para operar a partir de um gerador interno na frequência especificada no projeto com atraso de partida de 64 ms. Estou adicionando um arquivo com o projeto compilado. Frequência 8 MHz.
Mas como já escrevi no início, também existem outros símbolos na biblioteca. É verdade que não existem letras, apenas números. Agora vamos complicar um pouco a tarefa. Que a inscrição não seja inerte, mas mude. Digamos que conte de 0 a 9 com intervalo de 1 segundo. Quando chegar a 9, ele será zerado e começará novamente. Vamos pegar números grandes medindo 24*32. Bem, vamos começar. Você pode pegar o projeto anterior e excluir as três linhas “print_string”. Imediatamente após adicionar as bibliotecas, vamos declarar uma determinada variável global. eu.
caractere m = 0;
Você pode simplesmente escrever:
Neste caso, será atribuído automaticamente o valor 0. No loop principal escrevemos isto:
char_24_32(m,35,2); //função de saída do símbolo 24*32
atraso_ms(1000); // espere 1 segundo
m++; //adiciona 1 à variável m
se(m>9)m=0; // Doença. Se a variável m for maior que 9, então m é igual a 0.
Fiz um pequeno vídeo do programa funcionando
Tentarei lhe dizer como fazer desenhos e exibi-los na tela. Como criar arrays e funções para produzi-los e como inverter uma imagem. As bibliotecas foram emprestadas do site cxem.net. Material preparado Bebida.
Discuta o artigo CONECTANDO UM DISPLAY A UM MICROCONTROLADOR
O que é parte integrante de um grande número de dispositivos eletrônicos? Claro, meios de indicação e saída gráfica de dados. É sempre mais cômodo e agradável para o usuário quando o resultado da “smart box” pode ser visto visualmente. Portanto, hoje conectaremos um display ao STM32 para exibir texto e números. O herói de nossos experimentos será uma exibição bastante popular da Winstar. Aliás, um esclarecimento importante apareceu nos comentários de que a metodologia é basicamente a mesma para todos os displays baseados em HD44780. Obrigado ao JekaKey pela adição importante)
Primeiro, o display deve estar conectado ao controlador. Baixe a folha de dados e procure a pinagem WH1602. Olhe aqui:
Como você já entendeu, exibir WH1602 tem 16 pinos. Vejamos cada um separadamente...
Os pinos Vss, Vdd e K precisam estar conectados ao terra e à alimentação, ou seja, exatamente como indicado na tabela, não há surpresas e nem mesmo o que discutir)
O pino número 3 é usado para ajustar o contraste - se aplicarmos +5V ali, não veremos absolutamente nada, e se curto-circuitarmos o pino com o terra, admiraremos duas fileiras de quadrados pretos 😉 Naturalmente, isso não nos convém , então precisamos pendurar ali um potenciômetro (resistor) com resistência variável) para ajustar o contraste. A melhor visibilidade dos caracteres é fornecida por uma tensão de 0,5-0,7 V neste pino de exibição.
O pino RS já é um pino que nós mesmos controlaremos usando um microcontrolador. Um nível de tensão baixo (0) neste pino significa que um comando será seguido, um nível alto (1) significa que agora haverá dados a serem gravados na memória do display.
Pino R/W - está claro aqui, ou lemos os dados (display sinalizador de ocupado, por exemplo), neste caso há 1 neste pino, ou escrevemos o comando/dados no display, então temos 0 aqui.
DB7 – DB0 – barramento de dados, e isso diz tudo)
O pino E é o chamado sinal de habilitação. É para isso que ele é necessário. Para trabalhar com o display - registrar dados ou emitir um comando - precisamos emitir um pulso positivo para este pino. Ou seja, o procedimento ficará assim:
- Nos pinos RS, R/W, DB7 - DB0 - os sinais necessários correspondentes ao nosso comando.
- Fornecemos um para o pino E.
- Zhdems (de acordo com a folha de dados – pelo menos 150 ns)
- Aplicamos um nível baixo (0) ao pino E.
Você precisa colocar 4,2 V na perna A/Vee para alimentar a luz de fundo da tela.
É assim que ocorre a comunicação com o display WH1602.
Descobrimos como conectar o WH1602, mas antes de passarmos ao exemplo, vamos ver quais comandos nosso monitor geralmente entende. Para fazer isso, vamos até a ficha técnica e encontramos uma tabela interessante:
Todos os comandos e sinais que devem estar nos pinos correspondentes do WH1602 para cada comando específico são descritos aqui. Por exemplo, queremos limpar o display, olhamos a tabela e aqui está o comando que precisamos! Tela clara!
Aplicamos zeros aos pinos RS, R/W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 e um ao pino DB0. Feito, o que vem a seguir? Isso mesmo, um no pino E, então espere um pouco e abaixe E para zero novamente. É isso, o display está limpo 😉 Pouco antes de executar o próximo comando você deve fazer uma pausa, indicada na ficha técnica de cada comando. Seria mais eficaz pesquisar o sinalizador de ocupado; assim que ele for redefinido para 0, você poderá continuar trabalhando. Existe também um comando especial para ler esta bandeira, então tudo fica claro) Vamos em frente...
E, na verdade, tudo está com a teoria, você já pode tentar escrever alguma coisa. Para facilitar o trabalho com o display, fiz uma pequena biblioteca, agora vamos ver como ela pode ser utilizada. Primeiro, baixe
Temos 2 arquivos à nossa disposição, MT_WH1602.c e MT_WH1602.h. Rasgamos o segundo, aqui precisamos selecionar os pinos e o controlador utilizado.
A propósito, meu display está conectado assim:
RS-PC2
R/W – PB10
E-PB14
DB7–PD2
DB6–PC12
DB5–PA8
DB4–PA10
DB3–PA15
DB2–PD11
DB1–PA3
DB0–PA5
Abra o arquivo MT_WH1602.h:
| #define PLATAFORMA (STM32F10x) |
A seguir, selecione os pinos do microcontrolador aos quais o display está conectado. Primeiro vamos definir quais portas usaremos. Quando me conecto, uso GPIOA, GPIOB, GPIOC e GPIOD, escrevemos:
Da mesma forma para outras pernas do microcontrolador.
Concluímos a configuração, vamos continuar) Para chamar os comandos dados no início do artigo, o arquivo MT_WH1602.c contém as seguintes funções (elas têm os nomes dos comandos, então acho que está tudo claro) :
| vazio MT_WH1602_ClearDisplay(void ); |
vazio 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 (endereço uint8_t);
void MT_WH1602_SetDDRAMAddress (endereço uint8_t);
| bool MT_WH1602_ReadBusy(void); vazio MT_WH1602_WriteData (dados uint8_t); /*******************************************************************/ Para alguns comandos precisamos passar parâmetros para a função, por exemplo: void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit);() ; Vejamos a tabela de comandos: Vemos que o comando Display ON/OFF não apenas liga/desliga o display, mas também ativa/desativa o cursor e o cursor piscando. Na folha de dados, esses bits de comando são designados como D, C e B, e os passamos como parâmetros para a função. Se precisarmos ligar o display e o cursor, mas desabilitar o piscar do cursor, chamamos o comando da seguinte forma: MT_WH1602_DisplayOnOff(1, 1, 0); Em geral tudo é simples 😉 Resumindo, criamos um novo projeto, adicionamos uma biblioteca para trabalhar com o display WH1602, criamos um arquivo .c vazio e começamos a preenchê-lo com código: //Inclui o arquivo da biblioteca MT_WH1602_WriteData(0x6D); /*******************************************************************/ |
MT_WH1602_Atraso(100); 
MT_WH1602_WriteData(0x69) ;
MT_WH1602_Atraso(100); 
MT_WH1602_WriteData(0x63) ;
MT_WH1602_Atraso(100);
MT_WH1602_WriteData(0x72) ;
- MT_WH1602_Atraso(100);
- MT_WH1602_WriteData(0x6F);
- MT_WH1602_Atraso(100);
- MT_WH1602_WriteData(0x74) ;
- MT_WH1602_Atraso(100); MT_WH1602_WriteData(0x65) ;.
2 MT_WH1602_Atraso(100); MT_WH1602_WriteData(0x63) ;
O módulo é conectado ao Arduino de forma padrão para o barramento I2C: o pino SDA do módulo é conectado à porta analógica A4, o pino SCL é conectado à porta analógica A5 do Arduino. O módulo é alimentado por +5 V do Arduino. O próprio módulo é conectado pelos pinos 1 a 16 aos pinos 1 a 16 correspondentes no display LCD.
3 Biblioteca para trabalho MT_WH1602_WriteData(0x63) ;
Agora precisamos de uma biblioteca para trabalhar com LCD através da interface I2C. Você pode usar, por exemplo, este (link na linha "Baixar código de amostra e biblioteca"). 
Arquivo baixado LiquidCrystal_I2Cv1-1.rar descompacte em uma pasta \bibliotecas\, que está localizado no diretório IDE do Arduino.
A biblioteca oferece suporte a um conjunto de funções padrão para telas LCD:
| Função | Propósito |
|---|---|
| Cristal Líquido() | cria uma variável do tipo LiquidCrystal e aceita parâmetros de conexão do display (números de pinos); |
| começar() | inicializar o display LCD, configurar parâmetros (número de linhas e caracteres); |
| claro() | limpar a tela e retornar o cursor à posição inicial; |
| lar() | retorne o cursor à posição inicial; |
| setCursor() | definir o cursor para uma determinada posição; |
| escrever() | exibe o símbolo na tela LCD; |
| imprimir() | exibe texto na tela LCD; |
| cursor() | mostra o cursor, ou seja, sublinhado sob o lugar do próximo caractere; |
| semCursor() | oculta o cursor; |
| piscar() | cursor piscando; |
| sem piscar() | Cancelar piscar; |
| noDisplay() | desligar o display enquanto salva todas as informações exibidas; |
| mostrar() | ligar o display enquanto salva todas as informações exibidas; |
| scrollDisplayLeft() | role o conteúdo do display 1 posição para a esquerda; |
| scrollDisplayRight() | role o conteúdo do display 1 posição para a direita; |
| rolagem automática() | habilitar rolagem automática; |
| semAutoscroll() | desabilitar rolagem automática; |
| esquerda para direita() | define a direção do texto da esquerda para a direita; |
| direita para esquerda() | direção do texto da direita para a esquerda; |
| criarChar() | cria um caractere personalizado para a tela LCD. |
4 Esboço para saída de texto para tela LCD via barramento I2C
Vamos abrir a amostra: Amostras de arquivos LiquidCrystal_I2C CustomChars e vamos retrabalhá-lo um pouco. Mostraremos uma mensagem ao final da qual haverá um símbolo piscando. Os comentários ao código comentam todas as nuances do esboço.
#incluir
atraso(500); lcd.setCursor(13, 1); // move o cursor para a linha 2, caractere 1 lcd.print(" "); atraso(500);
5 lcd.print("site"); // Texto de saída) void Aliás, os caracteres escritos pelo comando
lcd.createChar(); , permanecem na memória do display mesmo depois de desligar a energia, porque escrito para exibir ROM 1602. para display LCD {00000, 01010, 11111, 11111, 01110, 00100, 00000} Vamos dar uma olhada mais de perto na questão da criação de seus próprios símbolos para telas LCD. Cada caractere na tela consiste em 35 pontos: 5 largos e 7 altos (+1 linha de reserva para sublinhado). Na linha 6 do esboço acima, definimos uma matriz de 7 números:
6 (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Vamos converter números hexadecimais em binários:
. Esses números nada mais são do que máscaras de bits para cada uma das 7 linhas do símbolo, onde “0” denota um ponto claro e “1” um ponto escuro. Por exemplo, um símbolo de coração especificado como máscara de bits aparecerá na tela conforme mostrado na figura.
7 Controle de tela LCD via barramento I2C
Vamos fazer upload do esboço para o Arduino. A inscrição que especificamos com um cursor piscando no final aparecerá na tela.
O que está por trás Barramento I2C Como bônus, vejamos o diagrama de tempo para exibir os caracteres latinos "A", "B" e "C" no display LCD. Esses caracteres são armazenados na ROM do display e exibidos na tela simplesmente transmitindo seus endereços para o display. O diagrama é retirado dos pinos RS, RW, E, D4, D5, D6 e D7 do display, ou seja, já após o conversor FC-113 “barramento paralelo I2C”. Podemos dizer que estamos nos aprofundando um pouco mais no hardware. Diagrama de temporização da saída dos caracteres latinos “A”, “B” e “C” no display LCD 1602 O diagrama mostra que os caracteres que estão na ROM do display (ver página 11 da ficha técnica, link abaixo) são transmitidos em dois nibbles, o primeiro dos quais determina o número da coluna da tabela, e o segundo - o número da linha. Neste caso, os dados são “travados” na borda do sinal na linha(Seleção de registro) está em um estado lógico, o que significa que os dados estão sendo transferidos. Um estado baixo na linha RS significa que instruções estão sendo enviadas, que é o que vemos antes de cada caracter ser transmitido. Neste caso, é transmitido o código de instrução para retorno do carro à posição (0, 0) do display LCD, que também pode ser encontrado estudando a descrição técnica do display.
E mais um exemplo. Este diagrama de temporização mostra a saída do símbolo do Coração no display LCD.
Novamente, os dois primeiros impulsos Habilitar cumprir as instruções Lar()(0000 0010 2) - retorna o carro para a posição (0; 0), e os dois segundos - exibe no display LCD armazenado na célula de memória 3 10 (0000 0011 2) o símbolo “Coração” (instrução lcd.createChar(3, coração); esboço).
