- O módulo FC-113 é baseado no chip PCF8574T, que é um registrador de deslocamento de 8 bits - um expansor de E/S para o barramento serial I2C. Na figura, o microcircuito é designado DD1.
- R1 - aparador para ajustar o contraste do display LCD.
- O jumper J1 é usado para ligar a luz de fundo do display.
- Os pinos 1 a 16 são usados para conectar o módulo aos pinos do display LCD.
- As almofadas de contato A1 ... A3 são necessárias para alterar o endereço I2C do dispositivo. Soldando os jumpers apropriados, você pode alterar o endereço do dispositivo. A tabela mostra a correspondência entre endereços e jumpers: "0" corresponde a um circuito aberto, "1" - um jumper está instalado. Por padrão, todos os 3 jumpers estão abertos e o endereço do dispositivo 0x27.
2 Diagrama de fiação para display LCD para Arduino via protocolo I2C
O módulo é conectado ao Arduino como padrão para o barramento I2C: a saída SDA do módulo é conectada à porta analógica A4, a saída SCL é conectada à porta analógica A5 do Arduino. O módulo é alimentado por +5 V do Arduino. O próprio módulo é conectado pelos pinos 1…16 aos pinos correspondentes 1…16 no display LCD.
3 Biblioteca para trabalhar via protocolo I2C
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 suporta 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 de exibição (números de pinos); |
| começar() | inicialização do display LCD, configuração de parâmetros (número de linhas e símbolos); |
| Claro() | limpar a tela e retornar o cursor à sua posição original; |
| casa() | retorno do cursor à posição inicial; |
| setCursor() | definindo o cursor para uma determinada posição; |
| Escreva() | exibe o caractere na tela LCD; |
| imprimir() | exibe texto na tela LCD; |
| cursor() | mostra o cursor, ou seja sublinhando sob o próximo caractere; |
| noCursor() | oculta o cursor; |
| piscar() | cursor piscando; |
| noBlink() | cancelar piscando; |
| nenhuma exibição() | desligando o display enquanto salva todas as informações exibidas; |
| exibição() | ligar o display enquanto salva todas as informações exibidas; |
| scrollDisplayLeft() | rolar o conteúdo do display 1 posição para a esquerda; |
| scrollDisplayRight() | rolar o conteúdo do display 1 posição para a direita; |
| auto rolagem() | habilitar a rolagem automática; |
| noAutoscroll() | desligue a rolagem automática; |
| da 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; |
| createChar() | cria um símbolo 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 arquivo LiquidCrystal_I2C CustomChars e vamos mudar um pouco. Vamos exibir uma mensagem, no final da qual haverá um caractere piscando. Todas as nuances do sketch são comentadas nos comentários ao código.
#incluir
A propósito, os caracteres escritos pelo comando lcd.createChar(); permanecem na memória do visor mesmo depois que a energia é desligada. são gravados na ROM do display 1602.
5 Criando seus próprios símbolos para visor LCD
Vamos dar uma olhada mais de perto na questão de criar seus próprios símbolos para telas de LCD. Cada caractere na tela consiste em 35 pontos: 5 de largura e 7 de altura (+1 linha sobressalente para sublinhado). Na linha 6 do esboço acima, definimos uma matriz de 7 números: (0x0, 0xa, 0x1f, 0x1f, 0xe, 0x4, 0x0). Vamos converter números hexadecimais para binários: {00000, 01010, 11111, 11111, 01110, 00100, 00000} . Esses números nada mais são do que máscaras de bits para cada uma das 7 linhas do caractere, onde "0" denota um ponto claro e "1" um ponto escuro. Por exemplo, um símbolo de coração dado como uma máscara de bits aparecerá na tela conforme mostrado na figura.
6 Controle LCD via barramento I2C
Faça o upload do sketch para o Arduino. A inscrição que especificamos aparecerá na tela com um cursor piscando no final.
7 O que está por trás barramento I2C
Como bônus, considere o diagrama de tempo da saída dos caracteres latinos "A", "B" e "C" no visor LCD. Esses caracteres são armazenados na ROM do display e são exibidos na tela simplesmente passando seu endereço para o display. O diagrama é retirado das saídas 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 mergulhando um pouco “mais fundo” no “ferro”.
Diagrama de tempo para exibir os caracteres latinos "A", "B" e "C" no visor LCD 1602 O diagrama mostra que os caracteres que estão na ROM do display (ver página 11 do datasheet, link abaixo) são transmitidos em dois nibbles, o primeiro determina o número da coluna da tabela e o segundo determina o número da linha. Nesse caso, os dados são "travados" ao longo da borda do sinal na linha E(Ativar) e a linha RS(Seleção de registro, seleção de registro) está em um estado lógico, o que significa transferência de dados. O estado baixo da linha RS significa a transmissão de instruções, que vemos antes da transmissão de cada caractere. Nesse caso, é transmitido o código da instrução de retorno do carro para a 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 tempo mostra a exibição do símbolo do Coração no LCD.
Novamente, os dois primeiros impulsos permitir cumprir as instruções Casa()(0000 0010 2) - retorno do carro para a posição (0; 0), e os dois segundos - saída para o 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); retrato falado).
Talvez uma das telas mais populares do mercado. Construído no popular controlador HD44780U. A partir do nome do modelo, segue-se que a tela consiste em duas linhas de 16 caracteres. Não há suporte para o idioma russo neste modelo específico.
O barramento de dados sh2s permite conectar até 127 dispositivos através de dois fios e ao mesmo tempo. Este I2C é implementado no chip PCF8574T.
Diagrama de fiação:
Coisa azul - resistência variável, permite ajustar o contraste da tela.
O jumper à esquerda é responsável pela luz de fundo da tela.
Um bloco de 4 pinos é conectado ao arduino assim:
GND-GND
VCC - 5V
SDA - A4 (se Arduino MEGA, então para D20)
SCL - A5 (se Arduino MEGA, então para D21)
Biblioteca
Retrato falado
O display pode ter um endereço IIC diferente, em vez de 0x27 pode ser 0x3F. Para determinar com precisão o endereço, você pode usar o scanner de dispositivo i2c.
#incluir
O módulo LCD I2C permite conectar um display de caracteres à placa Arduino com apenas dois fios de sinal.
Componentes usados (compre da China):
. painel de controle
. Fios de conexão
Principais características técnicas:
Exibição: Caractere 16x02 ou 20x04
. Iluminação: Azul com caracteres brancos
. Contraste: ajustável por potenciômetro
. Tensão de alimentação: 5V
. Interface: I2C
. Endereço I2C: 0x27
. Dimensões: 82mm x 35mm x 18mm
Conectando ao Arduino
O módulo está equipado com um conector de 2,54 mm de quatro pinos
SCL: linha de relógio serial (Serial CLOCK)
SDA: linha de dados serial (Serial DAta)
VCC: potência "+"
GND: "-" potência
Os pinos responsáveis pela interface I2C em placas Arduino baseadas em diferentes controladores variam
Para trabalhar com este módulo, você precisa instalar a biblioteca LiquidCrystal_I2C1602V1
Baixe, descompacte e solte na pasta bibliotecas na pasta Arduino. Se no momento de adicionar a biblioteca a IDE do Arduino estava aberta, reinicie o ambiente.
Vamos direto ao esboço. Neste exemplo, exibiremos o padrão "Hello, world!" e para o endereço de nossa comunidade.
exemplo de código:
#incluirCriando seus próprios símbolos
Descobrimos a saída de texto, as letras do alfabeto inglês são costuradas na memória do controlador dentro da tela e não há problemas com elas. Mas o que fazer se o caractere desejado não estiver na memória do controlador?
Não importa, o caractere necessário pode ser feito manualmente. Este método parcialmente, limitado a 7 caracteres, ajudará a resolver o problema de saída.
A célula, nas telas que estamos considerando, tem uma resolução de 5x8 pixels. Toda a tarefa de criar um símbolo se resume a escrever uma máscara de bits e colocar uns nela em lugares onde os pontos devem queimar e zeros onde não.
No exemplo abaixo, vamos desenhar um rosto sorridente.
exemplo de código:
//Testado no Arduino IDE 1.0.5 // Adiciona as bibliotecas necessárias#incluirPrograma para fácil criação de símbolos
Nos comentários, um membro da comunidade soltou um link para um gerador de personagens
Cheguei aqui de uma boa loja Chip Resistor outro aparelho para estudar e usá-lo em aparelhos úteis. Este dispositivo acabou sendo aprimorado para controlar a tela LCD sob o controle do controlador HD44780, no modo de 4 bits. Para isso, é instalado na placa um microcircuito, que é um conversor do barramento I2C para uma porta paralela de 8 bits.A placa é divorciada de tal forma que pode ser imediatamente cruzada com o display LCD. A entrada é alimentada e linhas I2C. A placa imediatamente possui resistores pull-up nas linhas SCL e SDA, um potenciômetro para ajustar o contraste e alimentar o próprio display.
O jumper à direita liga/desliga a luz de fundo. Então, armado com um testador, a seguinte placa foi compilada. Após estudar o módulo, descobriu-se que P3 controla a luz de fundo. Se o jumper estiver definido, 1 liga a luz de fundo e 0 a desliga. Quando o jumper é removido, a luz de fundo está sempre desligada. Além disso, decidiu-se complementar a biblioteca axlib com funções para trabalhar com o barramento I2C (implementação de software) e funções para controlar o chip PCF8574. Em poucas palavras, como o módulo funciona. Para emitir bytes em paralelo, para isso você precisa enviar o endereço do microcircuito para o barramento I2C (por padrão é 0x4E. Você também pode alterar o endereço soldando jumpers na placa e alterando o valor dos três menos dígitos significativos do endereço), então após receber o ACK, um byte de dados é enviado. Depois que o chip responde com ACK, o byte aparece na porta paralela do chip. Para controlar o LCD, peguei as funções da biblioteca axlib e as reformulei um pouco para trabalhar com o barramento I2C. #incluir
BYTE pcf8574_test(BYTE add) ( BYTE ask = ACK; add &= 0xFE; i2c_start(); ask = i2c_send_byte(add); i2c_stop(); return ask; ) A primeira função foi escrita para verificar se um dispositivo está no barramento. Em princípio, pode ser usado para procurar qualquer dispositivo localizado no barramento. A função pega o endereço do dispositivo desejado e, se responder, retorna zero. Se o dispositivo com este endereço não estiver no barramento, ele retornará um.
BYTE pcf8574_byte_out(BYTE data, BYTE add) ( BYTE ask = ACK; add &= 0xFE; i2c_start(); ask = i2c_send_byte(add); if(!ask) ask = i2c_send_byte(data); i2c_stop(); return ask; ) Esta função já foi aprimorada exclusivamente para este chip. Como argumentos, é passado um byte para transmissão ao barramento e o endereço do microcircuito. A função primeiro consultará o chip no endereço e, em seguida, enviará um byte. Se o chip recebeu o byte e respondeu com um ACK, a função encerrará o chip e retornará zero como um byte bem-sucedido. E o microcircuito neste momento enviará esse byte para sua porta paralela. Caso contrário, obtemos NACK e devolvemos um, a transferência falhou.
BYTE pcf8574_str_out(BYTE *data, BYTE col, BYTE add) ( BYTE ask = ACK; add &= 0xFE; i2c_start(); ask = i2c_send_byte(add); for(BYTE i=0; i
void com(BYTE com) ( com |= 0x08; // P3 para um, para que a luz de fundo fique acesa pcf8574_byte_out(com, ADD); // Saída de dados com |= 0x04; // E para um pcf8574_byte_out(com, ADD); // Saída de dados com &= 0xFB; //E para zero pcf8574_byte_out(com, ADD); // Saída de dados
}
Esta função apenas envia comandos para o display. Daí a primeira linha apareceu com a adição lógica do comando de 0x08. Este byaka é necessário devido ao fato de que não transmitimos os bytes diretamente para a porta do LCD, mas através do nosso repetidor. Ou seja, se enviarmos um byte e precisarmos gerar apenas um bit, então, por favor, ele atribuirá o bit necessário ao byte anterior e o enviará para a porta novamente. Este é um congelamento. A adição com 0x08 é necessária para manter permanentemente um no terceiro dígito. Lembra da luz de fundo? É esta adição que acende a luz de fundo. Depois chamamos a função de transferir um byte para o barramento. Foi escrito sobre acima. Em seguida, transferimos o byte pelo barramento para o microcircuito. Em seguida, você deve configurá-lo para a unidade E, que é o que a adição lógica de um byte com 0x04 realmente faz. Após zerar E. Assim, você pode enviar qualquer comando para o display apenas passando o próprio comando como argumento. void init(void) ( _delay_ms(30); // Pausa após ligar com(0x30); // Muda para o modo de 4 bits _delay_us(40); // Atraso para execução do comando com(0x30); // Muda para o modo de 4 bits _delay_us(40); // Atraso para execução do comando com(0x30); // Muda para o modo de 4 bits _delay_us(40); // Atraso para execução do comando com(0x20); // Muda para o modo de 4 bits _delay_us(40); // Atraso para execução do comando com(0x20); //Definir opções com(0x80); //Definir opções com(0x00); // Desligue a tela com(0x80); // Desligue a tela com(0x00); //Limpa a tela com(0x10); //Limpa a tela com(0x00); // Define o modo de entrada com(0x60); // Define o modo de entrada com(0x00); // Liga o display com o cursor selecionado com(0xC0); // Liga o display com o cursor selecionado
}
Esta função diz respeito apenas à inicialização do display. A sequência de comandos é retirada da folha de dados no display LCD. void char_out(BYTE data) ( BYTE data_h = ((data & 0xF0) + 0x09); BYTE data_l = ((data // Passa 4 bits altos data_h |= 0x04; pcf8574_byte_out(data_h, ADD); // Passa 4 bits altos data_h &= 0xF9; pcf8574_byte_out(data_h, ADD); // Passa 4 bits altos pcf8574_byte_out(data_l, ADD); // Passa 4 bits baixos data_l |= 0x04; pcf8574_byte_out(data_l, ADD); // Passa 4 bits baixos data_l &= 0xF9; pcf8574_byte_out(data_l, ADD); // Passa 4 bits baixos
}
Esta função envia dados para o LCD. É executado da mesma forma que os comandos, exceto que a transmissão de um byte ocorre primeiro com o nibble alto e depois com o baixo. E o resto é igual. void str_out(BYTE *str) ( while((*str) != "\0") ( char_out(*str); str++; ) ) Bem, esta função é puramente para passar uma string para o display. Na verdade, não tem nada a ver com o nosso tópico.
Projeto para AtmelStudio 6.2
Competente 01.08.15 17:11
A vírgula está faltando. Correto: "OLÁ MUNDO!" E este dispositivo é aprimorado não apenas para HD44780. Resistores de pull-up são colocados do lado do mestre. De acordo com a especificação, os dados são gravados no controlador LCD em E descendente. A partir daqui, a primeira função é simplificada: void com(BYTE com) ( com |= 0x08; // backlight pcf8574_byte_out(com | 0x04, ADD);/ / Saída de dados pcf8574_byte_out(com , ADD); // E para zero ) Sim, e o resto também pode ser significativamente menor. Por exemplo, void char_out(BYTE data) serão apenas duas chamadas, e ainda mais sem variáveis adicionais. A inicialização do LCD foi realizada com violações da especificação de tempos.
Alexey 02.08.15 19:11
Devido à falta de uma vírgula, a tela não sofrerá. Este dispositivo foi projetado especificamente para monitores com este ou um controlador similar. Mas é o microcircuito que é realmente um expansor de porta simples. Concordo com o E. Variáveis adicionais são necessárias. Se você passar um argumento para uma função e executar algumas ações com lógica, podem ocorrer falhas. Já encontrou isso. A inicialização é executada sem violações de tempo. A documentação diz que há uma pausa de 40 µs entre os comandos. Pelo fato de a transferência passar pelo barramento i2c, que por sua vez é software e lento, os prazos estão mais do que cumpridos. Se você não é muito preguiçoso, então escreva sua própria versão e envie para mim. Eu vou publicá-lo. Enfim, este site é destinado a um público amador e quem quiser pode expressar sua opinião e visão para a vida do MK.
Alexey 06.08.15 09:14
Adicionados tempos ao inicializar a exibição na observação do respeitado "Competente"
Dmitry 14.06.16 21:57
Olá Alexey. Você pode adicionar uma biblioteca ao gerador de código para trabalhar com PCF8574.
Alexey 14.06.16 22:32
Vou pensar.))
ruslan 21.12.16 19:54
Alexey 21.12.16 21:53
Oh sim. Especialmente o código em asma. Arduiners irão apreciá-lo ao máximo)))
Py.sy.
Mesmo se você não olhar para asm, então o programa é escrito sob o controlador PIC. É esta informação "muito" útil para as pessoas AVR? especialmente para iniciantes))) Não tenho nada contra PIC, mas mesmo PIC e AVR têm asm diferentes. E quanto aos detalhes da tela LCD, você pode olhar))) É verdade, eu também escrevi em CVAVR, mas todos os comandos foram classificados e classificados. Mas em qualquer caso, decida por si mesmo onde está escrito com mais clareza))) O autor escreve, o leitor escolhe.
GeK 04.01.17 12:52
"Endereço do chip I2C (o padrão é 0x4E"
Os 4 bits superiores do endereço são fixos,
prefixo PCF8574 é 0100 e PCF8574A é 0111
Os 3 bits inferiores dependem do estado das entradas do microcircuito A2-A0. Por padrão, todos os 3 jumpers estão abertos, respectivamente, o endereço do microcircuito é 0111111.
// A2 A1 A0 PCF8574 PCF8574A
// 1 1 1 0x20 0x38
// 1 1 0 0x21 0x39
// 1 0 1 0x22 0x3A
// 1 0 0 0x23 0x3B
// 0 1 1 0x24 0x3C
// 0 1 0 0x25 0x3D
// 0 0 1 0x26 0x3E
// 0 0 0 0x27 0x3F
Alexey 04.01.17 14:27
Você misturou alguma coisa.
Extrato da documentação do microcircuito
0b01001110 é 0x4E
Então está tudo aqui. E se você precisar alterar o endereço, basta alterá-lo no define.
Yuri 14.12.17 21:26
Bom dia! E você também pode usar o código de função lcdgotoxy e lcdclear para trabalhar com o adaptador no PCF8574.
Alexandre 20.05.18 18:14
Bom dia! como você exibe o texto russo.
Alexey 20/05/18 23:04
Este é um display doméstico da MELT. Ele tem o alfabeto cirílico costurado em sua memória.
Alexandre 21.05.18 04:55
Bom dia! Eu escrevo como você tem no projeto para AtmelStudio 6.2 "ЁPҐBET MҐP!" ele sai bem
e se você escrever "HELLO WORLD!" traz à tona todo tipo de bobagem. Eu tenho dois
variante de displays em um é costurado em cirílico. segundo chinês.
Alexey 21/05/18 09:22
Eu escreveria um programa de teste primeiro. Enumeração de toda a memória com exibição de caracteres e seus endereços. E então descobrir qual é o problema. Muito provavelmente a tabela de caracteres não corresponde à tabela ASCII.
Andrey 03.09.18 08:32
Boa tarde!
Você não pode enviar um esquema para Proteus?
Andrey 03.09.18 10:22
Ou ninguém verificou em Proteuse?
Andrey 03.09.18 10:56
Descobriu main_init
Pavel 30/05/19 23:35
Uma coisa curiosa, o endereço do display é 0x4E, e se o mesmo display estiver conectado a um arduino, então o endereço é 0x27
Pavel 31/05/19 11:04
Muito obrigado pelo seu trabalho! Eu procurei em toda a internet e nenhum dos exemplos acima funciona, exceto o seu. A única coisa é que no arquivo do projeto, os atrasos _delay_ não são registrados na função de inicialização do display e não funciona adequadamente
Alexey 01/06/19 09:52
Bem, este é mais um projeto de demonstração. Para sempre, você precisa reescrever a biblioteca axlib, mas dado o fato de que STM32 e STM8 estão se movendo aos trancos e barrancos, não há nenhum ponto no AVR.
Pavel 05.06.19 12:57
O STM não possui pacotes DIP, é mais difícil fazer placas de circuito impresso. Para meus projetos, os recursos do AVR são suficientes com margem, cabe muita coisa em um Atmega 8
Alexey 05.06.19 15:20
Sim, mas quanto custa Atmega8 e stm8s003)))
Dmitry 06/07/19 00:41
Olá Alexei.
Você pode me dizer como ler o status da porta do pcf8574?
Eu quero fazer uma unidade externa, 8 GPIOs no barramento i2c - é isso.
Dmitry 07.06.19 17:56
vou me responder
A função retorna um byte - o estado das portas do microcircuito
uint8_t pcf8574_byte_rcv(uint8_t addr)
{
uint8_t perguntar = ACK;
endereço |= 0b01; //LER
uint8_tdata=0;
i2c_start();
perguntar = i2c_send_byte(addr);
if(!ask) dados = i2c_read_byte(NACK);
i2c_stop();
dados de retorno;
}
Pavel 06/07/19 20:37
Quanto custa, 150 rublos, pelo preço de um revezamento em geral), mas como você cria placas para STM? LUT não é confiável, roteador CNC não tem certeza do que será necessário (não tentei)
tela de LCD- um convidado frequente em projetos arduino. Mas em circuitos complexos, podemos ter o problema de falta de portas Arduino devido à necessidade de conectar um shield que tenha muitos pinos. A saída nesta situação pode ser I2C/IIC um adaptador que conecta um shield Arduino 1602 quase padrão a placas Uno, Nano ou Mega com apenas 4 pinos. Neste artigo, veremos como conectar uma tela LCD com uma interface I2C, quais bibliotecas podem ser usadas, escrever um pequeno exemplo de esboço e analisar erros típicos.
Visor de cristal líquido LCD 1602é uma boa escolha para a saída de cadeias de caracteres em vários projetos. É barato, existem várias modificações com diferentes cores de luz de fundo, você pode facilmente baixar bibliotecas prontas para esboços do Arduino. Mas a principal desvantagem desta tela é o fato de que o display possui 16 pinos digitais, dos quais são necessários pelo menos 6. Portanto, usar esta tela LCD sem i2c adiciona sérias limitações para placas Arduino Uno ou Nano. Se não houver contatos suficientes, você terá que comprar uma placa Arduino Mega ou salvar contatos, inclusive conectando o monitor via i2c.
Breve descrição dos pinos LCD 1602
Vamos dar uma olhada nos pinos do LCD1602:
Cada uma das conclusões tem o seu propósito:
- Terra GND;
- Alimentação 5 V;
- Configurando o contraste do monitor;
- Comando, dados;
- Escrita e leitura de dados;
- permitir;
7-14. Linhas de dados;
- Além de luz de fundo;
- Menos luz de fundo.
Especificações de exibição:
- Tipo de display simbólico, é possível carregar símbolos;
- Luzes LED;
- Controlador HD44780;
- Tensão de alimentação 5V;
- Formate 16x2 caracteres;
- Faixa de temperatura de operação de -20C a +70C, faixa de temperatura de armazenamento de -30C a +80C;
- Ângulo de visão 180 graus.
Diagrama de fiação para LCD para placa Arduino sem i2C
O esquema padrão para conectar um monitor diretamente a um microcontrolador Arduino sem I2C é o seguinte.
Devido ao grande número de contatos a serem conectados, pode não haver espaço suficiente para conectar os elementos necessários. O uso de I2C reduz o número de fios para 4 e os pinos ocupados para 2.
Onde comprar telas LCD e shields para arduino
A tela LCD 1602 (e a versão 2004) é bastante popular, então você pode encontrá-la facilmente tanto em lojas online domésticas quanto em sites estrangeiros. Aqui estão alguns links para as opções mais disponíveis:
  Módulo de tela azul LCD1602+I2C compatível com Arduino
|   Display LCD1602 simples (luz de fundo verde) mais barato que 80 rublos
|   Tela grande LCD2004 com I2C HD44780 para arduino (luz de fundo azul e verde)
|
 Display 1602 com adaptador IIC e luz de fundo azul
|  Outra versão do LCD1602 com um módulo I2C soldado
|   Módulo adaptador de porta IIC/I2C/TWI/SPI para 1602 Shield compatível com Arduino
|
  Visor retroiluminado RGB! LCD 16×2 + teclado +Buzzer Shield para Arduino
|  Escudo para Arduino com botões e tela LCD1602 LCD 1602
|  Display LCD para impressora 3D (Smart Controller for RAMPS 1.4, Text LCD 20×4), módulo leitor de cartão SD e MicroSD
|
Descrição do protocolo I2C
Antes de discutir a conexão de um monitor a um arduino por meio de um adaptador i2c, vamos falar brevemente sobre o próprio protocolo i2C.
I2C / IIC(Inter-Integrated Circuit) é um protocolo originalmente criado para interconectar circuitos integrados dentro de um dispositivo eletrônico. O desenvolvimento pertence à Philips. O protocolo i2c é baseado no uso de um barramento de 8 bits, necessário para conectar blocos na eletrônica de controle, e um sistema de endereçamento, graças ao qual você pode se comunicar com vários dispositivos pelos mesmos fios. Simplesmente transferimos os dados para um ou outro dispositivo, adicionando o identificador do elemento desejado aos pacotes de dados.
O circuito I2C mais simples pode conter um mestre (na maioria das vezes um microcontrolador Arduino) e vários escravos (por exemplo, um display LCD). Cada dispositivo possui um endereço na faixa de 7 a 127. Não deve haver dois dispositivos com o mesmo endereço no mesmo esquema.
A placa Arduino suporta i2c em hardware. Você pode usar os pinos A4 e A5 para conectar dispositivos usando este protocolo.
Existem várias vantagens em trabalhar com I2C:
- Apenas 2 linhas são necessárias para operação - SDA (linha de dados) e SCL (linha de clock).
- Conexão de um grande número de dispositivos líderes.
- Reduzindo o tempo de desenvolvimento.
- Apenas um microcontrolador é necessário para controlar todo o conjunto de dispositivos.
- O número possível de microcircuitos conectados a um barramento é limitado apenas pela capacidade máxima.
- Alto grau de segurança de dados devido a um filtro especial de supressão de surtos integrado aos circuitos.
- Procedimento simples para diagnosticar falhas emergentes, solução de problemas rápida.
- O barramento já está integrado ao próprio Arduino, portanto não há necessidade de desenvolver uma interface de barramento adicional.
Imperfeições:
- Há um limite capacitivo na linha - 400 pF.
- Dificuldade em programar o controlador I2C se houver vários dispositivos diferentes no barramento.
- Com um grande número de dispositivos, torna-se difícil localizar uma falha se um deles definir incorretamente um estado de baixo nível.
Módulo i2c para LCD 1602 Arduino
A maneira mais rápida e conveniente de usar um monitor i2c no arduino é comprar uma tela pronta com suporte de protocolo integrado. Mas essas telas não são muito e não são baratas. Mas um grande número de várias telas padrão já foi lançado. Portanto, a opção mais acessível e popular hoje é comprar e usar um módulo I2C separado - um adaptador parecido com este:
De um lado do módulo, vemos os pinos i2c - terra, alimentação e 2 para transferência de dados. No outro adaptador vemos os conectores de alimentação externa. E, claro, existem muitos pinos na placa, com a ajuda dos quais o módulo é soldado aos pinos da tela padrão.
As saídas I2c são usadas para conectar à placa Arduino. Se necessário, conecte uma fonte de alimentação externa para iluminação. Com o aparador embutido, podemos ajustar os valores de contraste ajustáveis J
No mercado, você encontra módulos LCD 1602 com adaptadores já soldados, seu uso é simplificado ao máximo. Se você comprou um adaptador separado, precisará pré-soldá-lo ao módulo.
Conectando a tela LCD ao Arduino via I2C
Para conectar, você precisa da própria placa Arduino, um display, uma placa de ensaio, fios de conexão e um potenciômetro.
Se você estiver usando um adaptador i2c separado especial, você deve primeiro soldá-lo ao módulo de tela. É difícil cometer um erro lá, você pode ser guiado por esse esquema.
Um monitor LCD habilitado para i2c é conectado à placa usando quatro fios - dois fios para dados, dois fios para alimentação.
- O pino GND está conectado ao GND na placa.
- O pino VCC é de 5V.
- SCL está conectado ao pino A5.
- SDA está conectado ao pino A.
E é tudo! Sem teias de fios, nas quais é muito fácil se confundir. Ao mesmo tempo, podemos simplesmente confiar toda a complexidade da implementação do protocolo i2C às bibliotecas.
Bibliotecas para trabalhar com display LCD i2c
Para fazer a interface do Arduino com o LCD 1602 através do barramento I2C, você precisará de pelo menos duas bibliotecas:
- A biblioteca Wire.h para trabalhar com I2C já está disponível no programa IDE padrão do Arduino.
- A biblioteca LiquidCrystal_I2C.h, que inclui uma ampla variedade de comandos para controlar o monitor através do barramento I2C e permite tornar o esboço mais fácil e curto. Você precisa instalar adicionalmente a biblioteca Depois de conectar o monitor, você precisa instalar adicionalmente a biblioteca LiquidCrystal_I2C.h
Depois de conectar todas as bibliotecas necessárias ao sketch, criamos um objeto e podemos usar todas as suas funções. Para testar, vamos carregar o seguinte esboço padrão do exemplo.
#incluir
Descrição das funções e métodos da biblioteca LiquidCrystal_I2C:
- home() e clear() - a primeira função permite retornar o cursor ao início da tela, a segunda também, mas ao mesmo tempo exclui tudo o que estava no monitor antes.
- write(ch) - permite imprimir um único caractere ch na tela.
- cursor() e noCursor() - mostra/oculta o cursor na tela.
- blink() e noBlink() - o cursor pisca/não pisca (se sua exibição foi habilitada antes).
- display() e noDisplay() - permite ativar/desativar a exibição.
- scrollDisplayLeft() e scrollDisplayRight() - rola a tela um caractere para a esquerda/direita.
- autoscroll() e noAutoscroll() - permite ativar/desativar o modo autoscroll. Neste modo, cada novo caractere é escrito no mesmo lugar, substituindo o que foi escrito anteriormente na tela.
- leftToRight() e rightToLeft() - Define a direção do texto exibido - da esquerda para a direita ou da direita para a esquerda.
- createChar(ch, bitmap) - Cria um caractere com o código ch (0 - 7) usando uma matriz de bitmaps de bitmap para criar pontos pretos e brancos.
Biblioteca alternativa para trabalhar com tela i2c
Em alguns casos, ao usar a biblioteca especificada com dispositivos equipados com controladores PCF8574, podem ocorrer erros. Neste caso, a biblioteca LiquidCrystal_PCF8574.h pode ser oferecida como alternativa. Ele estende LiquidCrystal_I2C, portanto, não deve haver problemas ao usá-lo.
problemas de conexão do monitor i2c lcd
Se você não vir nada na tela após carregar o esboço, tente as etapas a seguir.
Primeiro, você pode aumentar ou diminuir o contraste do monitor. Muitas vezes, os caracteres simplesmente não são visíveis devido ao modo de contraste e luz de fundo.
Se isso não ajudar, verifique a conexão correta dos contatos, se a luz de fundo está ligada. Se você usou um adaptador i2c separado, verifique novamente a qualidade da soldagem dos contatos.
Outro motivo comum para a falta de texto na tela pode ser o endereço i2c errado. Tente primeiro alterar o endereço do dispositivo no esboço de 0x27 0x20 ou para 0x3F. Diferentes fabricantes podem ter diferentes endereços padrão. Se isso não ajudar, você pode executar o esboço do scanner i2c, que verifica todos os dispositivos conectados e determina seu endereço por força bruta. Um esboço de exemplo de um scanner i2c.
Se a tela ainda não funcionar, tente dessoldar o adaptador e conectar o LCD da maneira usual.
Conclusão
Neste artigo, abordamos os principais problemas do uso da tela LCD em projetos complexos do Arduino quando precisamos salvar pinos livres na placa. Um adaptador i2c simples e barato permitirá conectar uma tela LCD 1602, ocupando apenas 2 pinos analógicos. Em muitas situações isso pode ser muito importante. O preço por conveniência é a necessidade de usar um módulo adicional - um conversor e uma biblioteca. Em nossa opinião, este não é um preço alto por conveniência, e é altamente recomendável usar esse recurso em projetos.
