Como fazer amizade com uma placa Arduino com exibição de caracteres? Bem simples! Abaixo está tudo em ordem e com detalhes.
Se você deseja receber informações do Arduino sem conectar a um computador e enviar para uma porta serial, pode usar uma exibição de caracteres. Não é tão difícil de fazer. A conveniência obtida com a comunicação é inestimável.
Para o trabalho, usei um display LCD de caracteres J204A baseado no chip HD44780, frequentemente encontrado no eBay como LCD2004. 4 linhas de 20 caracteres, invertidas. Comprei com vários outros no eBay, por meros centavos, de 60 a 100 rublos cada. O idioma russo não é suportado por padrão, mas este é um problema solucionável, mais sobre isso na próxima vez. E os conectores do diagrama não são soldados, você terá que trabalhar com um ferro de solda.
A biblioteca é usada para trabalhar com displays. LiquidCrystal.h incluído no Arduino IDE padrão.
Mas não encontrei uma folha de dados para o display LCD2004, mas na Internet existem muitas tabelas no display. Mas eles praticamente não diferem um do outro. Controle e conexão são completamente idênticos. A diferença está apenas no número de linhas/caracteres no display. Mas isso absolutamente não afetará se você tiver 1602.
Todos os contatos são definidos na tabela. Se você pegar o visor e girá-lo em sua direção, os contatos estarão localizados da esquerda para a direita, respectivamente, na tabela eles vão em números crescentes. Na coluna de contatos, entre parênteses, é indicada a designação na folha de dados.
| # | Contatos | Para que serve | Observação |
| 1 | VSS (VSS) | GND. Terra. Fonte de alimentação do microcontrolador do display. | 0V |
| 2 | VDD (VCC) | Tensão de alimentação para o microcontrolador do display. | +5V |
| 3 | V0 (VEE) | Contraste de caracteres no visor. É melhor conectar através de um potenciômetro. | de 0v a +5V |
| 4 | RS (RS) | Seleção de registro. | |
| 5 | RW (R/W) | Alternando o modo de leitura/gravação. Vamos arrastá-lo para o chão, só precisamos transmitir informações para o display. | 0-gravação +5V-leitura |
| 6 | E | Cronometragem | |
| 7 | D0 (DB0) | Dados | |
| 8 | D1 (DB1) | Transferência de dados. (Não vai usar) | Dados |
| 9 | D2 (DB2) | Transferência de dados. (Não vai usar) | Dados |
| 10 | D3 (DB3) | Transferência de dados. (Não vai usar) | Dados |
| 11 | D4 (DB4) | Dados | |
| 12 | D5 (DB5) | Transferência de dados. (Noivo) | Dados |
| 13 | D6 (DB6) | Transferência de dados. (Noivo) | Dados |
| 14 | D7 (DB7) | Transferência de dados. (Noivo) | Dados |
| 15 | A (LED+) | +5V Tensão, luz de fundo da tela, brilho da tela podem ser ajustados via potenciômetro. | +5V |
| 16 | K(LED-) | GND Terra, luz de fundo da tela | 0V |
v
A transferência de dados para o display é possível em duas versões: 8 e 4 bits por ciclo. Porque O Arduino tem poucos contatos, usaremos 4 - isso é mais que suficiente para atualizar as informações no display em uma velocidade além da percepção.
É assim que eu tenho tudo conectado. Pode parecer um caos, mas existe um sistema. Você pode selecionar fios vermelhos, verdes, amarelos e laranja. Os vermelhos sempre vão para +5V, os verdes vão para GND, e os amarelos e laranjas são os fios de conexão com o Arduino, que transportam dados. 
A parte mais importante é a conexão física do display. Clique para abrir em alta resolução onde tudo é claramente visível.
R1 - resistor de 200OM. Resistência limitando a corrente que passa pela luz de fundo do display.
R2 - Potenciômetro com resistência de até 10kOM. Rolamos a caneta, selecionamos o contraste dos personagens. 
E um esboço extremamente simples para exibir algumas linhas na tela.
H> // Conectamos a biblioteca para trabalhar com o display. /* LiquidCrystal lcd(rs, ativar, d4, d5, d6, d7); crie uma variável do tipo LiquidCrystal E determine por quais contatos o Arduino trabalha com o display. mais sobre este comando aqui http://arduino.cc/en/Reference/LiquidCrystalConstructor */ LiquidCrystal lcd(6, 7, 8, 9, 10, 11); void setup() ( lcd.begin(20, 4); // define características de exibição (20 caracteres por linha, 4 linhas) // Para exibição 1602, especifique lcd.begin(16, 2); lcd.setCursor(1, 1); // Especifique de qual posição começar a saída de texto. linhas e caracteres começam em 0!!! // 1 já moverá o cursor uma divisão desde o início da tela e deslocará o texto uma linha abaixo lcd.print( "compblog.vlukyanov" ); // imprime o texto começando na posição especificada. lcd.setCursor(7, 2); // imprime a partir do 8º caractere na tela na terceira linha. lcd.print(".com") ; // texto para imprimir. ) void loop() ( // não faça mais nada no loop, tudo já está feito durante a inicialização da placa. )
Resultado. Se você sabe como tudo se conecta e como escrever código, o tempo para todo o trabalho é de 5 minutos. 
Além disso, o display pode executar algumas funções por conta própria e também é possível definir alguns parâmetros.
Por exemplo:
E agora o bônus!
A luz de fundo da tela consome energia, o que, por exemplo, gostaria de economizar bateria. Eu fiz essa opção para mim - quando você pressiona o botão, a luz de fundo da tela acende por 5 segundos.
H> // Conectamos a biblioteca para trabalhar com o display. int botãoInt = 0; // Número de interrupção a ser chamado. int telaLed = 4; // O número do pino ao qual a tela está conectada. +5V volátil longo x = 5000; // variável para armazenar LiquidCrystal time lcd(6, 7, 8, 9, 10, 11); void setup() ( attachInterrupt(buttonInt, screenon, FALLING); // configurações de interrupção lcd.begin(20, 4); pinMode(screenLed, OUTPUT); digitalWrite(screenLed,HIGH); // ativa a exibição lcd.setCursor( 0 , 0); lcd.print("Iniciar tela no teste!"); ) // A função que será executada quando o botão for clicado. void screenon() ( x = millis()+5000; // Lembra a hora de desligar a luz de fundo. Tempo de execução atual +5 segundos. digitalWrite(screenLed,HIGH); // Aplica tensão na luz de fundo do display. ) void loop () ( lcd.setCursor(0, 2); // vai para a terceira linha lcd.print(x); // e imprime a hora em que o display desliga lcd.setCursor(0, 3); // vai para a quarta linha lcd.print( millis()); // imprime o tempo de execução atual if (x< millis()) // если время работы выключения наступило >(digitalWrite(screenLed,LOW); // depois desliga o display) )
E o resultado:
Com base no controlador HD44780, os monitores LCD 1602 ainda são um dos monitores mais acessíveis, simples e sob demanda para desenvolver qualquer tipo de dispositivos eletrônicos. Não é de surpreender que possam ser vistos tanto em unidades simples montadas literalmente no joelho, quanto em unidades industriais mais sérias, como máquinas de café. É com esse display que os módulos e shields mais populares do Arduino são montados, por exemplo, o módulo LCD I2C e o LCD Keypad Shield.
Este artigo explica em detalhes com imagens como conectar o LCD ao Arduino e exibir as informações.
1602 monitores têm duas versões diferentes:
Luz de fundo amarela com letras pretas
- ou (isso acontece com muito mais frequência) luz de fundo azul com branco.
As dimensões dos monitores no controlador HD44780 são muito diferentes, mas são controladas da mesma forma. As dimensões mais comuns são 16 por 02 (ou seja, 16 caracteres em duas linhas) ou 20 por 04. Os próprios caracteres têm resolução de 5 por 8 pixels.
A maioria dos monitores não suporta cirílico (com exceção dos monitores de marcação CTK). Mas esse problema é parcialmente solucionável e, em seguida, o artigo detalha como fazê-lo.
O monitor possui um conector de 16 pinos para conexão. As conclusões têm marcando com verso honorários, é o seguinte:
1 (VSS) - potência para menos para o controlador.
2 (VDD) - fonte de alimentação positiva para o controlador.
3 (VO) - configurações de controle de contraste.
4 (RS) – seleção para registro.
5 (R/W) - ler e escrever, em particular, escrever quando conectado ao terra.
6 (E) – ativação (habilitar).
7-10 (DB0-DB3) - bits baixos da interface de oito bits.
11-14 (DB4-DB7) - bits mais significativos da interface
15 (A) - ânodo positivo para alimentar a luz de fundo.
16 (K) - cátodo negativo para alimentar a luz de fundo.
Antes de conectar o display e transferir informações para ele, vale a pena verificar seu desempenho. Primeiro, aplique tensão ao controlador VSS e VDD, ligue a luz de fundo (A, K) e ajuste o contraste. Para tais configurações, um potenciômetro de 10 kΩ é adequado, seu formato não é importante. +5V e GND são aplicados nas pernas extremas, e a perna no centro é conectada à saída VO.
Quando a energia é aplicada ao circuito, é necessário obter o contraste necessário; se for ajustado incorretamente, a imagem na tela não ficará visível. Para ajustar o contraste, você precisa "brincar" com o potenciômetro. Quando o circuito é montado corretamente e o contraste é ajustado corretamente, a linha superior da tela deve ser preenchida com retângulos.
Para que o display funcione, é utilizada a biblioteca especial LiquidCrystal.h embutida no IDE do Arduino, sobre a qual escreverei a seguir. Ele pode operar no modo de 8 bits e 4 bits. Na primeira variante, apenas os bits baixos e altos (BB0-DB7) são usados, na segunda, apenas os bits baixos (BB4-DB7).
Mas o uso do modo de 8 bits neste display é uma decisão errada, quase não há vantagem na velocidade, já que sua taxa de atualização é sempre inferior a 10 vezes por segundo. Para exibir texto, você precisa conectar os pinos DB7, DB6, DB5, DB4, E e RS aos pinos do controlador. Você pode conectá-los a qualquer pino do Arduino, o principal é definir a sequência correta no código.
Se o caractere necessário ainda não estiver na memória do controlador, ele pode ser determinado manualmente (até sete caracteres no total). A célula nos displays em consideração tem uma extensão de cinco por oito pontos. A tarefa de criar um símbolo é escrever uma máscara de bits e colocar uns nos lugares onde os pontos devem queimar e zeros onde não devem.
O esquema de conexão discutido acima nem sempre é bom, pois o Arduino utiliza pelo menos seis saídas digitais.
Vamos explorar uma maneira de contornar isso e sobreviver com apenas dois. É necessário um módulo conversor LCD para IIC/I2C adicional. Como ele é soldado ao display e acoplado ao Arduino pode ser visto nas imagens abaixo.
Mas esta opção de conexão funciona apenas com a biblioteca especial LiquidCrystal_I2C1602V1, que, no entanto, é fácil de encontrar na Web e instalar, após o que você pode usá-la sem problemas.
A biblioteca LiquidCrystal.h pode ser baixada do recurso oficial - . Você também pode baixar nos links abaixo:
Depois de baixar o arquivo, substitua a pasta LiquidCrystal na pasta de bibliotecas do diretório de instalação do Arduino.
Você pode ver um esboço de exemplo em Arquivo -> Exemplos -> LiquidCrystal -> HelloWorld_SPI(Arquivo -> Exemplos -> LiquidCrystal -> HelloWorld_SPI).
Isso conclui nossa próxima lição. Desejamos-lhe projetos de qualidade!
O que é uma parte essencial um grande número dispositivos eletrônicos? Claro, meios de indicação e saída de dados gráficos. É sempre mais conveniente e agradável para o usuário quando o resultado da "caixa inteligente" pode ser visto visualmente. Portanto, hoje vamos conectar um display ao STM32 para exibir texto e números. O herói de nossos experimentos será uma exibição bastante popular da Winstar. A propósito, um esclarecimento importante apareceu nos comentários de que a técnica é basicamente a mesma para todos os displays baseados em HD44780. Obrigado a JekaKey por uma adição importante)
Para começar, o monitor deve estar realmente conectado ao controlador. Baixe o datasheet e procure a pinagem WH1602. Olhe aqui:
Como você sabe, exibir WH1602 tem 16 pinos. Vamos ver cada um individualmente...
Os pinos Vss, Vdd e K precisam ser conectados ao terra e à alimentação, ou seja, diretamente conforme indicado na tabela, não há surpresas e nem há o que discutir)
O pino número 3 serve para ajustar o contraste - se aplicarmos +5V ali, não veremos absolutamente nada, e se encurtarmos o pino no chão, admiraremos duas fileiras de quadrados pretos 😉 Naturalmente, isso não nos convém, então nós precisa pendurar um potenciômetro (resistor com resistência variável) para ajustar o contraste. A melhor visibilidade dos caracteres é fornecida por uma voltagem de 0,5-0,7 V neste pino de exibição.
O pino RS já é uma saída que nós mesmos controlaremos usando um microcontrolador. Um nível de baixa tensão (0) neste pino significa que um comando seguirá agora, alto nível(1) - significa que agora haverá dados a serem gravados na memória do display.
Pin R / W - está claro aqui, ou lemos os dados (o sinalizador de ocupado do display, por exemplo), neste caso, este pino é 1, 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. Ele é necessário para isso. Para trabalhar com o display - gravar dados ou dar um comando - precisamos dar um pulso positivo a este pino. Ou seja, o procedimento ficará assim:
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 a conexão WH1602, mas antes de passar para o exemplo, vamos considerar quais comandos nossa tela entende em geral. Para fazer isso, subimos na folha de dados e encontramos uma tabela interessante:
Descreve todos os comandos e sinais que devem estar nos pinos WH1602 correspondentes para cada comando específico. Por exemplo, queremos limpar o display, olhar a tabela, e aqui está o comando certo! exibição clara!
Alimentamos com zeros os pinos RS, R / W, DB7, DB6, DB5, DB4, DB3, DB2, DB1 e uma unidade na perna DB0. Concluído! O que vem a seguir? Isso mesmo, um no pino E, espere um pouco e abaixe E novamente para zero. Pronto, o display está limpo 😉 Só que antes de executar o próximo comando, você deve fazer uma pausa, indicada no datasheet de cada comando. Será mais eficiente pesquisar o sinalizador de ocupado, assim que ele for redefinido para 0, você poderá continuar trabalhando. Também existe um comando especial para ler este sinalizador, então tudo fica claro com isso) Vamos em frente ...
E, na verdade, isso é tudo 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. Para começar, baixe
Colocamos à nossa disposição 2 arquivos, MT_WH1602.c e MT_WH1602.h. Arrancamos o segundo, aqui precisamos fazer uma escolha das conclusões e do controlador utilizado.
A propósito, meu monitor 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) |
Em seguida, selecione os pinos do microcontrolador aos quais o display está conectado. Apenas primeiro, vamos definir quais portas envolvemos. Aqui, quando me conecto, uso GPIOA, GPIOB, GPIOC e GPIOD, escrevemos:
Da mesma forma para outras pernas do microcontrolador.
Terminamos as configurações, vamos continuar) Para chamar os comandos fornecidos no início do artigo, o arquivo MT_WH1602.c contém as seguintes funções (elas recebem o nome dos nomes dos comandos, então acho que está tudo claro aqui ):
| void MT_WH1602_ClearDisplay(void); void 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); void MT_WH1602_WriteData(uint8_t data); |
Para alguns comandos, precisamos passar parâmetros para a função, por exemplo:
| void MT_WH1602_DisplayOnOff (bool Dbit, bool Cbit, bool Bbit); |
Veja 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 piscar do cursor. Na folha de dados, esses bits de comando são designados como D, C e B, e então os passamos como parâmetros para a função. Se precisarmos habilitar o display e o cursor, mas desabilitar a piscada do cursor, chamamos o comando da seguinte forma:
MT_WH1602_DisplayOnOff(1, 1, 0);
Em geral, tudo é simples 😉
Resumindo, criamos novo projeto, adicione a biblioteca para trabalhar com o display WH1602, crie um arquivo .c vazio e comece a preenchê-lo com o código:
| // Inclui o arquivo da biblioteca#include "MT_WH1602.h" /*******************************************************************/ int main(vazio) ( // Chama a função de inicialização, sem isso, em lugar nenhum =)() ; // Agora precisamos fazer a configuração inicial do display // A documentação e a internet recomendam fazer isso ;) MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_FunctionSet(1, 1, 1); MT_WH1602_Delay(1000); MT_WH1602_DisplayOnOff(1, 0, 0); MT_WH1602_Delay(1000); MT_WH1602_ClearDisplay() ; MT_WH1602_Delay(2000); // Aqui peguei os primeiros valores do delay para um exemplo que me veio a cabeça) // Em geral, você precisa verificar o sinalizador de ocupado de exibição // Vamos agora exibir algo como o nome do nosso site MT_WH1602_WriteData(0x6D); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x69); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x72); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x6F); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x74); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x65); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x68); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x6E); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x69); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x63); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x73); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x2E); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x72); MT_WH1602_Delay(100); MT_WH1602_WriteData(0x75); MT_WH1602_Delay(100); enquanto (1) (__NOP();)) /*******************************************************************/ |
Pronto, confira) 
Como você pode ver, tudo funciona corretamente)
A propósito, de alguma forma perdi de vista a questão do que escrever na tela para exibir este ou aquele caractere. Aqui está a placa da folha de dados: 
Portanto, para determinar qual valor gravar na memória do display, você precisa pegar os números escritos na parte superior e deixados nesta tabela para um caractere específico. Por exemplo, o caractere "A". Nós olhamos - este caractere corresponde à coluna 0100 (0x4) e à linha 0001 (0x1). Acontece que para exibir o caractere “A”, você precisa escrever o valor 0x41 no display.
Agora tudo parece estar =) Descobrimos a conexão e operação do display WH1602, então até breve!
PS Ao trabalhar com a biblioteca, não testei a função de leitura do sinalizador de ocupado, então se de repente algo não funcionar como deveria, escreva, daremos um jeito)
Esta instrução mostra como conectar ao Arduino e usar telas LCD em 16x2 e 20x4.
Esses monitores têm uma luz de fundo LED de baixa potência integrada e operam a partir de +5 V. Para conectar esses monitores LCD, você precisa de 6 pinos. Você pode usar qualquer pino no seu Arduino!
A instrução é escrita com base nas telas LCD Adafruit - azul e branco 16x2, RGB 16x2 LCD e azul e branco 20x4, RGB 20x4. Se você estiver usando uma tela LCD de outro fabricante, não há 100% de garantia de que funcionará (embora em 99% dos casos funcione).
Há um grande número de telas LCD diferentes. Neste artigo, veremos LCDs de caracteres. Telas como essas são uma ótima opção para exibir texto. Você também pode personalizar a exibição dos ícones, mas o tamanho desses ícones não deve exceder 7 pixels (muito pequenos!).
A foto abaixo mostra um exemplo de monitor LCD de 16 caracteres com duas linhas:
Se você olhar de perto, verá pequenos retângulos onde os símbolos são exibidos. Cada retângulo é uma grade separada de pixels. Para comparação, a tela LCD gráfica é mostrada abaixo:
A tela gráfica de cristal líquido possui uma grande grade de pixels (em este exemplo- 128x64). Você pode exibir texto nele, mas é melhor exibir imagens. Os LCDs gráficos são geralmente maiores, têm mais pinos para conectar e são um pouco mais difíceis de usar do que os LCDs de texto.
Neste artigo, abordaremos apenas telas de texto/caracteres!
Depois de limitarmos o tipo de tela em questão, vamos ver o que são.
Embora sejam usados apenas para exibir texto, existem diferentes modelos e fatores de forma: no canto superior esquerdo está um LCD 20x4 com texto branco sobre fundo azul, no canto superior direito está um 16x4 com texto preto sobre fundo verde, em o canto inferior esquerdo é um 16x2 com texto branco sobre fundo azul e 16x1 com texto preto sobre fundo cinza.
A boa notícia é que todas essas telas são intercambiáveis. Se você personalizou um deles, pode substituí-lo por outro modelo. O esboço do Arduino terá que ser ligeiramente modificado, mas a fiação é a mesma!
Nesta parte utilizamos telas LCD com um trilho e 16 pinos para conexão (veja foto acima). Há também um LCD com 2 trilhos com 8 pinos para conexão (na figura abaixo).
Conectar o segundo modelo a uma placa de circuito sem solda é mais difícil.
Além da tela LCD, você precisará de cintas adicionais. Primeiro, um potenciômetro de 10 kΩ. Usando o potenciômetro, vamos ajustar o contraste do display. Cada tela LCD tem diferentes configurações de contraste, então você não pode ficar sem ajuste. Além disso, você precisará de um trilho de pinos de 0,1".
Se o trilho com contatos for muito longo, está na moda simplesmente cortar os contatos extras!
Você precisa soldar os pinos ao LCD.
Ao soldar, tenha muito cuidado para não danificar sua Breadboard! Você pode primeiro "pegar" o primeiro e 16 contatos e depois soldar o resto.
Explicações |
|
|---|---|
 |
Estamos começando a entrar em algumas coisas interessantes! Monte seu LCD na placa de ensaio. |
 |
Nós alimentamos a breadboard do nosso Arduino. Conecte +5V ao trilho vermelho e Gnd ao azul. |
 |
Depois disso, vamos conectar a luz de fundo da nossa tela LCD. Conecte o pino 16 ao GND e o pino 15 a +5V. A maioria das telas LCD possui resistores de luz de fundo. Se não houver resistores em seu módulo, você terá que adicionar um entre 5V e o pino 15. Para calcular o valor dos resistores, verifique no datasheet a corrente máxima para alimentar o backlight e o valor aproximado da queda de tensão. Subtraia a queda de tensão de 5V e divida por força máxima corrente e arredonde para o valor do resistor padrão mais próximo. Por exemplo, se a queda de tensão for de 3,5 V e a corrente for de 16 mA, o valor do resistor será: (5 - 3,5)/0,016 = 93,75 ohms ou 100 ohms arredondados para o valor padrão. Se você não conseguir encontrar uma folha de dados, use um resistor de 220 ohms. É verdade que, neste caso, a luz de fundo pode ser bastante pálida. |
 |
Conecte seu Arduino à energia. A luz de fundo deve acender. |
A propósito, algumas telas LCD baratas não têm luz de fundo!
Explicações |
|
|---|---|
 |
Instale o potenciômetro. Na foto, ele está localizado à direita do pino 1. |
 |
Conecte um lado do potenciômetro a +5V e o outro lado a Gnd. Conecte o pino do meio do potenciômetro ao pino 3 no LCD. |
 |
Agora conectamos a lógica da nossa tela - este é um circuito separado da luz de fundo! O pino 1 vai para Gnd e o pino 2 vai para +5V. |
 |
Ligue seu Arduino. Se o monitor LCD tiver luz de fundo, ele deve acender. Gire o botão do potenciômetro para ver o primeiro retângulo de pixels na primeira linha. |
Se tudo funcionou, parabéns. Isso significa que lógica, iluminação e contraste funcionam! Se não deu certo, não prossiga para as próximas etapas da instrução até descobrir qual é o erro!
D0 a D7, RS, EN e RW. D0-D7 são os pinos que armazenam os valores enviados ao display. O pino RS informa ao controlador se vamos exibir dados (por exemplo, um caractere ASCII) ou se é um byte de controle (por exemplo, alterar a posição do cursor). O pino EN é a abreviação de "enable", com este pino informamos ao LCD quando os dados estão prontos para serem lidos. O pino RW é usado para definir a direção - queremos exibir (geralmente) ou ler (menos comumente usado) os dados do visor.
Nem todos esses pinos precisam ser conectados ao Arduino. Por exemplo, não é necessário usar RW se apenas exibirmos dados na tela, basta "puxá-lo" para o pino Gnd. Além disso, é possível se comunicar com a tela LCD usando 4 pinos em vez de 8. Provavelmente surge uma pergunta natural, em que casos são usados 8 pinos? Muito provavelmente, isso afeta a taxa de transferência de dados. Ou seja, usando 8 contatos em vez de 4, você pode aumentar em 2 vezes a velocidade de troca de informações. NO este caso, a velocidade não é importante, então usamos 4 pinos para conectar o LCD ao Arduino.
Então, precisamos de 6 pinos: RS, EN, D7, D6, D5 e D4.
Para trabalhar com a tela LCD, usaremos a biblioteca LiquidCrystal, que simplifica muito o processo de configuração dos pinos. Uma das vantagens desta biblioteca é que você pode usar qualquer pino do Arduino para conectar os pinos do LCD. Portanto, no final deste guia, você poderá alterar facilmente os pinos se isso for crítico para o seu projeto.
Explicações |
|
|---|---|
 |
Como mencionado acima, não usaremos o pino RW, então o puxamos para o chão. Este é o pino 5. |
 |
Depois de conectar RS - este é o pino nº 4. Estamos usando o fio marrom para conectá-lo ao pino digital nº 7 do Arduino. |
 |
Com um fio branco, conecte o pino EN - pino nº 6 ao pino digital nº 8 do Arduino. |
 |
Chegou a vez dos contatos de dados. DB7 é o pino 14 no LCD. Ele se conecta com o fio laranja ao pino #12 no Arduino. |
 |
Restam três pinos de dados, DB6 (pino 13 amarelo), DB5 (pino 12 verde) e DB4 (pino 11 azul). Eles se conectam aos pinos #11, 10 e 9 no Arduino, respectivamente. |
 |
Como resultado da conexão, você obterá algo semelhante à foto à esquerda. |
É hora de carregar o esboço no Arduino para controlar a tela LCD. A biblioteca LiquidCrystal é instalada no Arduino IDE por padrão. Então só precisamos baixar um dos exemplos e ajustar um pouco de acordo com os pinos que usamos para conectar.
Abra o sketch File→Examples→LiquidCrystal→HelloWorld.
Atualizando informações sobre pinos. Procurando a seguinte linha:
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
E altere para:
Agora você pode compilar e enviar o sketch para o Arduino.
Ajuste o contraste, se necessário.
Naturalmente, você pode usar o display LCD em qualquer tamanho. Por exemplo, a foto abaixo mostra o funcionamento do LCD 20x4.
Ou texto preto sobre fundo verde:
Uma das vantagens das telas com texto em preto sobre fundo verde é a capacidade de desligar a luz de fundo.
Vamos ver como o LCD lida com mensagens longas e usa múltiplas linhas. Por exemplo, se você alterar a seguinte linha:
lcd.print("olá, mundo!");
Para o próximo:
lcd.print("olá, mundo! esta é uma longa mensagem");
O LCD 16x2 truncará tudo após o 16º caractere:
Mas um display LCD 20x4 carregará caracteres não exibidos da primeira linha para a terceira (a segunda linha continuará na quarta). Não é muito conveniente, mas nesta fase você tem que aguentar. Portanto, ao exibir strings longas, conte os caracteres para não exceder o comprimento permitido.
Essas telas funcionam como telas normais, mas existem três LEDs (vermelho, verde, azul) para iluminação de fundo, para que você possa usar Cores diferentes iluminação.
Após conectar o LCD e verificar de acordo com as instruções acima, conecte os LEDs aos pinos analógicos PWM do seu Arduino para ajustar a cor. Se você estiver usando um Arduino Uno, deverá ter três pinos PWM livres. conecte o LED vermelho (pino 16 do LCD) ao Digital 3, o LED verde (pino 17) ao Digital 5 e o LED azul (pino 18 do LCD) ao digital 6. O módulo LCD já possui resistores, então você não precisa conectar adicional necessário.
Agora carregue o esboço abaixo para o Arduino.
// inclui as bibliotecas no esboço:
#incluir
#incluir
#define REDLITE 3
#define GREENLITE 5
#define BLUELITE 6
// declara o número de contatos que usamos
// para transferência de dados
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
// o brilho pode ser alterado na faixa de 0 -> 255
brilho int = 255;
// define o número de colunas e linhas no LCD:
lcd.begin(16, 2);
// exibe a mensagem no LCD.
lcd.print("Exibição RGB 16x2");
lcd.setCursor(0,1);
lcd.print("LCD multicolorido");
pinMode(REDLITE, OUTPUT);
pinMode(GREENLITE, OUTPUT);
pinMode(AZUL, OUTPUT);
brilho = 100;
para (int i = 0; i< 255; i++) {
setBacklight(i, 0, 255-i);
para (int i = 0; i< 255; i++) {
setBacklight(255-i, i, 0);
para (int i = 0; i< 255; i++) {
setBacklight(0, 255-i, i);
void setBacklight(uint8_t r, uint8_t g, uint8_t b) (
// configure o LED vermelho - é mais brilhante que o resto!
r = mapa(r, 0, 255, 0, 100);
g = mapa(g, 0, 255, 0, 150);
r = mapa(r, 0, 255, 0, brilho);
g = mapa(g, 0, 255, 0, brilho);
b = mapa(b, 0, 255, 0, brilho);
// ânodo comum, então inverta!
r = mapa(r, 0, 255, 255, 0);
g = mapa(g, 0, 255, 255, 0);
b = mapa(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(AZUL, b);
O resultado deste esboço é mostrado no vídeo abaixo.
Você provavelmente vai querer usar caracteres especiais. Por exemplo, se você estiver projetando um projeto usando um sensor de temperatura (termopar), o símbolo (°) será útil.
Isso pode ser feito usando o comando createChar. Além disso, você pode encontrar um ótimo site que faz todo o trabalho sujo de criar novos símbolos para você!
Deixe seus comentários, dúvidas e compartilhe experiência pessoal abaixo de. Na discussão muitas vezes nascem novas ideias e projetos!
Durante todo o tempo da minha paixão por eletrônica, usei LCDs de vários fabricantes - DataVision, WINSTAR, Uniworld Technology Corp.. Eles diferiam no tipo de controlador, no número de pinos e no comprimento das linhas, mas ao mesmo tempo todos tinham o mesmo esquema de conexão, sistema de comando e eram atendidos pelo mesmo programa do microcontrolador. Portanto, embora agora falemos sobre a exibição WINSTAR WH0802A, todas as opções a seguir se aplicam a LCDs de caracteres de outros fabricantes.
Alguns monitores têm dois saída adicional– saídas de retroiluminação +LED e –LED. Além disso, se houver conclusões, isso não significa que também haja luz de fundo. Bem como vice-versa. Meu monitor tem luz de fundo, mas não tem pinos de controle.
Por padrão, a luz de fundo do monitor WH0802A-YGH-CT está desligada. Para ligá-lo, você precisa fazer algumas manipulações simples, ou seja, instalar dois jumpers e soldar um resistor limitador de corrente (veja a foto RK, JF e RA, respectivamente).
isto esquema típico ligue o LCD de caracteres. Não usaremos o esquema de controle de luz de fundo da tela, mas desenhei apenas por precaução.
Depois de aplicar energia ao circuito, você precisa ligar o regulador de contraste (resistor R1). Se a linha superior aparecer na tela, significa que ela está ativa e é hora de começar a escrever o código. No Estado inicial usaremos um barramento de 8 bits. Para obter os primeiros resultados, precisamos escrever duas funções - uma função para escrever dados e uma função para escrever comandos. Eles diferem em apenas uma linha - quando os dados são escritos, o sinal RS deve ser 1, quando um comando é escrito, o RS deve ser 0. Não usaremos as funções de leitura ainda, portanto o sinal R / W será sempre 0.
O ciclo de gravação para um barramento de 8 bits é assim:
1. Defina RS (0 - comando, 1 - dados)
2. Envie o valor do byte de dados para o barramento DB7…DB0
3. Defina E=1
4. Atraso do programa 1
5. Defina E=0
6. Atraso do programa 2
O controlador de LCD de caracteres não tem velocidade infinita, então atrasos de software são usados entre algumas operações. O primeiro é necessário para manter o sinal estroboscópico por um tempo, o segundo, para que o controlador tenha tempo de gravar dados ou executar um comando. Os valores de atraso são sempre fornecidos na descrição do controlador de exibição e você deve sempre manter pelo menos seu valor mínimo, caso contrário, falhas na operação do controlador são inevitáveis.
Em geral, o controlador de exibição possui o chamado sinalizador de ocupado - BF. Se o sinalizador for 1, o controlador está ocupado, se for 0, está livre. Em vez de um segundo atraso de software, você pode ler o sinalizador de ocupado e verificar quando o controlador de exibição está livre. Mas como queremos obter rapidamente os primeiros resultados, lidaremos com o sinalizador de ocupado mais tarde.
//porta na qual o barramento de dados do LCD está conectado
#define PORT_DATA PORTD
#define PIN_DATA PIND
#define DDRX_DATA DDRD
//porta onde estão conectados os pinos de controle
#define PORT_SIG PORTB
#define PIN_SIG PINB
#define DDRX_SIG DDRB
// números dos pinos do microcontrolador
//ao qual os pinos de controle do LCD estão conectados
#define RS 5
#define RW 6
#define PT 7
// macros para trabalhar com bits
#define ClearBit(reg, bit) reg &= (~(1<<(bit)))
#define SetBit(reg, bit) reg |= (1<<(bit))
#define F_CPU 8000000
#define _delay_us(nós) __delay_cycles((F_CPU / 1000000) * (nós));
#define _delay_ms(ms) __delay_cycles((F_CPU / 1000) * (ms));
//função de entrada de comando
vazio LcdWriteCom( caracter não identifcado dados)
{
ClearBit(PORT_SIG, RS); // define RS como 0
PORT_DATA = dados; // saída de dados para o barramento
SetBit(PORT_SIG, EN); // define E como 1
_delay_us(2);
ClearBit(PORT_SIG, EN); // define E como 0
_delay_us(40);
//função de escrita de dados
ClearBit(PORT_SIG, EN); // define E como 0
atraso_us(40);
}
int a Principal( vazio
)
{
enquanto
(1);
Retorna
0;
}
Não há lugares complicados aqui, tudo deve estar claro. Ir em frente.
Qualquer LCD deve ser inicializado antes do uso. O processo de inicialização geralmente é descrito na folha de dados do controlador de exibição. Mas mesmo que não haja nenhuma informação ali, é provável que a sequência seja assim.
1. Sirva a comida2. Aguarde >40ms
3. Damos o comando Function set
DL– bit para definir a largura do barramento
Barramento de 0 a 4 bits, barramento de 1 a 8 bits
N– bit para definir o número de linhas de exibição
0 - modo de linha única, 1 - modo de duas linhas
F- bit de configuração de fonte
0 - formato 5*8, 1 - formato 5*11
* - não importa o que estará nesses bits
4. Dê o comando Display ON / OFF
D– exibe o bit de ativação/desativação
0 - tela desligada, 1 - tela ligada
C– bit de ativação/desativação do cursor
0 - cursor desativado, 1 - cursor ativado
B– bit de habilitação de cintilação
0 - cursor piscando habilitado, 1 - cursor piscando desabilitado
5. Dê o comando Clear Display
6. Aguardando > 1,5 ms
7. Dê o comando Entry Mode Set
EU IRIA– ordem de aumento/diminuição do endereço de DDRAM (display RAM de dados)
0 - o cursor se move para a esquerda, o endereço diminui em 1, 1 - o cursor se move para a direita, o endereço aumenta em 1
SH– ordem de deslocamento de todo o display
0 - sem deslocamento, 1 - o deslocamento ocorre de acordo com o sinal I / D - se for 0 - o display é deslocado para a direita, 1 - o display é deslocado para a esquerda
Para o nosso exemplo, a função de inicialização ficará assim
