Olá novamente, Habr! Tendo traduzido o artigo sobre o gerenciamento do módulo LCD com um driver, mas sem minha própria RAM de vídeo, decidi traduzir outra publicação sobre o mesmo tópico. Aqui o módulo já é mais simples, monocromático, mas "reviver" não é menos interessante.

Controle de LCD com driver, mas sem controlador

A exibição com a qual o autor vai trabalhar é tirada de uma biblioteca de fitas antiga. O controlador não sobreviveu, mas uma pesquisa por qualquer coisa relacionada a "263645-001" mostrou que havia um FPGA. Acredita-se que controle diretamente esses módulos de LCD do Arduino, etc. impossível, você precisa de um link intermediário - o controlador da série SEDxxxxx, que não é "amigável" com a placa de ensaio e tem mais entradas do que o próprio módulo. Mas isso não é verdade. Aqui estão quatro projetos semelhantes:

No ATmega8515
Nele
Na foto
No ESP32

E alguns até operam com monitores AVR VGA de oito bits ...

Em geral, o autor conseguiu, o software sob a licença MIT está aqui .

Imagem estática

Para garantir que tudo funcione, você deve primeiro tentar gerar uma imagem rasterizada de bit único da memória flash do microcontrolador. Para obter uma tensão negativa, pegamos três "Crones", a tensão do divisor, que foi usada como um resistor de sintonia, foi aplicada ao terminal V0. E aqui na tela é Lenna:



O autor ainda não consegue entender como conseguiu virar a imagem (veja de que lado está o cabo). De qualquer forma, existe este exemplo na página do projeto no GitHub.

Modo de texto

Mas a ROM de vídeo é de pouca utilidade e não há 9600 bytes para a RAM de vídeo no Arduino. O modo de texto é útil, no qual a ROM do gerador de caracteres e a RAM de vídeo combinada são menores que a RAM de vídeo no modo gráfico. Os defensores da República do Cazaquistão e o "especialista" podem quebrar lanças sem parar sobre esse assunto.



Um pequeno exemplo na linguagem assembly AVR:

... lpm r24, Z ;---------- (CL2 rising edge) out %[data_port], r24 ld r30, X+ swap r24; (CL2 rising edge) out %[data_port], r24 lpm r24, Z ;---------- (CL2 rising edge) out %[data_port], r24 ... 

Hardware necessário

Para o módulo F-51543NFU-LW-ADN / PWB51543C-2-V0, o autor aplicou:

Arduino no AVR com uma frequência de clock de 16 MHz (testado em Uno, Leonardo e um clone semelhante ao ProMicro).

Fonte de tensão negativa. Para o autor, este é um conversor DC-DC não estabilizado A0524S-1W com isolamento de entrada e saída. Conversores para o MC34063 também são adequados (esse chip é muito fácil de encontrar - basta desmontar o carregamento USB mais barato para um isqueiro) ou MAX749. A estabilização não é necessária, a faixa de tensões permitidas nesta entrada para o módulo usado aqui é bastante ampla. O valor nominal é menos 24 V, o máximo é menos 30 em relação ao fio comum e 35 entre Vdd e Vee. O consumo atual é de 6 mA.

Dois transistores MOS de canal N com controle de nível lógico. O autor usou o IRL530n, o estoque, é claro, é grande, mas certamente não queimará. Um transistor controla a luz de fundo, o outro uma fonte de tensão negativa.

Resistor de corte de 250 kΩ para fornecer tensão à entrada V0. Defina de modo que -16,8 V a uma temperatura de +25 ° C no contato móvel. Isso é de uma folha de dados e, portanto, é claro, essa precisão não é necessária.

Vários resistores de 10 quilos para puxar para baixo.

Layout e jumpers.

O que você faria agora? Relógio QR? Pergunte ao kote:



O Kote oferece a implementação de uma simulação de algum LCD comum com um controlador. Para que outro "pensamento" que funcione com a tela do HD44780, apenas grande, possa ser conectado a este Arduino.

Fonte - também na RAM

Tomamos um exemplo com EGA e VGA - lá, ao trabalhar no modo de texto, foi feito exatamente isso. Só aqui havia 64 caracteres no total, mas pelo menos tudo entrou na RAM, ao contrário do modo gráfico. É verdade que o ciclo principal de eventos ficou mais lento, mas você pode tentar gráficos em bloco:

Modo gráfico e meio-tom

No Arduino no AVR, não há muita RAM, e esse é o ponto. Mesmo em Mega. 320x240, mesmo com um bit por pixel - já são 9600 bytes. Apenas quatro meios-tons exigirão o dobro. Com a RAM externa, por exemplo, 23LC512 no modo SQI, você pode tentar implementar algo semelhante ao DMA, mas é mais simples e lucrativo refazer tudo no ESP32, onde há mais RAM estática e o DMA é mais fácil.

Se você quiser apenas conectar esse monitor a um PC via USB, tente usar o ATmega32u4 para isso - haverá recursos suficientes mesmo para gradações de brilho (usando FRC, o que está descrito na minha tradução anterior). Mas não com o "mega" usado como conversor de interface, mas com um PC que escaneia o LCD em tempo real a uma velocidade de 5,4 megabits por segundo.

Quando o módulo ainda estava na biblioteca de fitas, havia uma GUI e gradações de brilho - tudo estava lá.

Atualizações serão. Enquanto isso ...



E isso não é uma montagem de fotos, mas o resultado do controle de um PC. E mudaremos do Hackaday.io para o GitHub - ainda há muitas coisas interessantes no README.md.

Sinais para controlar esses módulos

FLM - Marcador de primeira linha - marcador de primeira linha, também pode ser chamado de FRAME, VSYNC, etc.
CL1 - Pulso de trava de linha - pulso de seqüência de gravação, também pode ser chamado. CARGA, HSYNC, etc.
CL2 - Clock de deslocamento de pixel - pulso de mudança de pixel, também pode ser chamado. CP (alterar pixel) etc.
M - sinal alternativo, devido ao qual os pixels são controlados por tensão alternada, também pode ser chamado de BIAS (offset), etc.

D0-D3 é um barramento de dados paralelo de quatro bits.

Linhas para fio comum, energia de luz de fundo (por exemplo, VLED ±), energia do módulo (VEE e V0)

Não negligencie as planilhas de dados. O módulo pode exigir outra voltagem negativa, ou pode ser positivo, ou o conversor pode estar embutido. A lógica pode diferir, por exemplo, com uma unidade no CL1, não haverá reação no CL2. Pode haver uma luz de fundo diferente (CCFL (com cuidado, o inversor é uma "mordida") em vez de LEDs) ou a pinagem não é indicada na placa, é impossível reconhecê-la sem uma folha de dados. Você não pode conectar nada aleatoriamente.

O que há para fazer

Transmitir a cadeia em pedaços de quatro bits, a gravação é realizada no declínio na linha CL2. Depois de passar a linha, anote a recessão na linha CL1 (sim, afinal, um pouco de RAM no módulo está em uma linha). A próxima linha será selecionada automaticamente. Após transmitir o quadro inteiro, retorne ao início usando o sinal FLM. Em uma folha de dados sobre LC79401, há um exemplo. Grave a uma velocidade suficiente, aplique pulsos no CL1 uniformemente. O controlador hesitou um pouco - a tela piscou feia.

Após cada quadro, altere o nível lógico na entrada M para o oposto, para que os pixels sejam controlados por tensão alternada. Caso contrário, a tela se deteriora:


Você não pode confiar nessa operação no microcontrolador, mas coloque um gatilho contável. Entrada para FLM, saída para M - em geral, é compreensível.

Um exemplo para saída de imagens da memória flash (consulte o início do artigo) é chamado clglcd_simple neste repositório.

Como já mencionado, é impossível fazer o mesmo com a RAM no Arduino no AVR - não será suficiente, portanto ...

E novamente - modo de texto

De acordo com a folha de dados, você pode transmitir dados em um barramento de quatro bits e "pull" CL2 com uma frequência de até 6 MHz. Portanto, você pode transferir a linha rápida e rapidamente, em seguida, o microcontrolador resolve um pouco outras tarefas e, conforme o timer o informa, "puxa" CL1 e repete o ciclo.

Ao gerar caracteres para uma resolução horizontal de 320 pixels, tudo isso pode ser feito em 20 µs (320 pixels / 4 bits = 80 pulsos, CL2 “puxa” com uma frequência de 4 MHz). Para as tarefas restantes, restam 39,5 μs. O CL1 “se move” a cada 59,5 μs e obtém uma taxa de quadros de 70 Hz. Bem, haverá mais procedimentos para lidar com interrupções e assim por diante, em geral, o microcontrolador estará ocupado controlando a tela 45% do tempo. "Total" 45 ou "total" 45? Provavelmente o segundo: substituir dados na RAM de vídeo pode ser rápido o suficiente.

Deseja que o microcontrolador gaste menos tempo gerenciando o indicador e mais em outras tarefas? Você pode reduzir a taxa de quadros para 50 Hz, pode fazer um overclock do microcontrolador para 20 MHz. Com qualquer um desses métodos, mais ciclos de clock ocorrerão entre as rotinas de interrupção.

Um timer de comparação de saída alterna a linha CL2 a cada quatro pulsos de clock com um ciclo de trabalho de 50%. Ao mesmo tempo, os dados vão para as saídas da porta PORTB, conectadas ao barramento de dados de quatro bits do módulo, de forma que mudem no momento em que o nível sobe para CL2 e, no momento do declínio, permanecem inalteradas. Obviamente, isso não pode ser feito sem o assembler:

 ... lpm r24, Z ;---------- (CL2 rising edge) out %[data_port], r24 ld r30, X+ swap r24; (CL2 rising edge) out %[data_port], r24 lpm r24, Z ;---------- (CL2 rising edge) out %[data_port], r24 ... 

8 ciclos - e quatro petiscos são transmitidos. E o que exatamente transmitir depende de qual símbolo está na célula de vídeo RAM correspondente, quais pixels correspondentes a esse símbolo devem ser transferidos da ROM do gerador de caracteres e o que é armazenado nas células correspondentes dessa ROM.

A coisa mais inconveniente aqui é a necessidade de parar o cronômetro após exatamente 80 pulsos. Alguns temporizadores, como o Timer4 em 32u4, não podem.

Para obter o sinal fornecido à linha CL1, o autor aplicou uma saída diferente do microcontrolador, destinado tanto ao timer quanto ao PWM rápido. Qual disso é aplicado aqui é compreensível. Ele alterna a cada 952 medidas. Ou, se você contar após o divisor do relógio em 8, ocorre a cada 119 pulsos. Nesse ponto, a rotina de processamento de interrupção inicia e força o microcontrolador a enviar novos dados para a linha de controle que serão necessários durante o próximo pulso para CL1. Bem, o nível na linha M muda com metade da frequência. E o LCD não se deteriora. Todos os sinais juntos são assim:



O gerador de caracteres consiste em 256 caracteres - o suficiente para 866, KOI-8R ou 1251. Os caracteres 40xN são colocados na RAM de vídeo, onde N é o número de linhas, dependendo da altura do caractere. A largura do símbolo é sempre 8 pixels e a altura pode ser 6, 8, 10, 12, 15, 16. Quanto menor, menor a ROM necessária para o gerador de caracteres e mais RAM de vídeo. Com uma fonte 8x8 (40 caracteres por 30 linhas), você precisa de 1200 bytes de RAM e 2048 bytes de ROM. Com uma fonte 8x16 (fica melhor neste módulo), a RAM precisa de 600 bytes e a ROM 4096. Do tradutor: você pode armazenar a fonte na forma de 8x8 e dimensioná-la verticalmente duas vezes por software, além de custar 600 bytes de RAM e 2048 ROM. Para armazenar várias fontes na ROM, é necessário manter o endereço inicial da fonte não constante, mas em uma variável, mas não funcionará para imprimir o texto em várias fontes de uma só vez, a menos que, é claro, você altere esse endereço imediatamente, através do procedimento de processamento de interrupção diretamente durante a transferência de pixels para a tela.

A fonte é armazenada assim: primeiro as linhas superiores de todos os 256 caracteres, depois uma linha abaixo e assim por diante. Há um script Python na pasta misc do repositório que converte automaticamente a fonte TTF no arquivo de cabeçalho clglcd_font.h com a matriz PROGMEM no formato necessário. As fontes clássicas de pixel para o CC-BY-SA 4.0 podem ser encontradas aqui .

E novamente - dê um exemplo com EGA e VGA

Mas desta vez com detalhes. O gerador de caracteres na RAM, como indicado acima, acomoda um total de 64 caracteres; eles podem ser identificados por números de 0 a n ou de 255 a 255. Eles são armazenados da mesma maneira: as linhas principais de todos os caracteres, a seguir, e assim por diante. Somente tudo isso está alinhado, levando em consideração o fato de que os caracteres não são 256, mas 64. Para caracteres com tamanho de 8x16 pixels, são necessários 16 * 64 = 1024 bytes. O repositório tem um exemplo de trabalho com o gerador de caracteres na RAM.

Se os dois geradores de caracteres forem usados ​​ao mesmo tempo - 256 caracteres na ROM e 64 caracteres na RAM, você terá que aceitar que não apenas haverá menos RAM, mas também a velocidade de transferência de linhas das linhas no módulo diminuirá - em vez de 8 ciclos de relógio, dois nibbles precisarão de 12, ou seja, não 20 microssegundos, mas 30, e em vez de 45% do tempo para o controle de LCD, serão necessários 60.

Modo gráfico de meio-tom

Como indicado acima, neste caso, o microcontrolador funciona simplesmente como um conversor de interface. Você precisará do ATmega32u4, e o que fazer é descrito aqui . Observe que o módulo pode ser danificado devido ao congelamento do programa no PC.

Então, o que é esse laço de quatro fios - do sensor resistivo, ao que parece.

Onde conectar

Conforme indicado acima, é necessária uma voltagem negativa, que nas primeiras experiências pode ser removida de três “crones” e, em seguida, monte o conversor, por exemplo, no MAX749. Os sinais de controle de potência, bem como o sinal DISPOFF (este é um sinal inverso, o módulo é ligado em um), puxe os resistores para baixo. Durante o piscar e reiniciando o microcontrolador, a aparência de unidades lógicas é inaceitável.

Aplique tensão negativa após tensão + 5V e uma unidade lógica na linha DISPOFF - quando os dados já estiverem presentes nas linhas de controle: pelo menos uma unidade no barramento de dados, unidade no CL1. Caso contrário, o módulo poderá falhar.

As entradas D0-D3 podem ser conectadas às saídas da mesma porta do microcontrolador, por exemplo, Px4-Px7, enquanto as saídas Px0-Px3 não podem ser usadas como GPIO. Você pode atribuir-lhes outras funções, por exemplo, usá-las como saídas de temporizadores, interfaces seriais, etc. Se você usá-los como entradas, tenha cuidado: os resistores de pull-up embutidos podem alternar arbitrariamente se não estiverem desativados (PUD - desativação de pull-up).

Entrada M - para a saída do timer de comparação ou PWM.

Entrada CL1 - para outra saída do mesmo timer.

Entrada CL2 - para a saída de outro cronômetro de comparação.

FLM - para qualquer saída digital.

DISPOFF - para qualquer outra saída digital.

O restante depende de como você liga o módulo. O autor prefere controlar a luz de fundo e o Vee separadamente.

Como usar o firmware

Coloque os arquivos clglcd.he clglcd.cpp no ​​sketch

Faça uma cópia de backup do arquivo clglcd_config.h e edite-o levando em consideração o que está conectado e as funções necessárias: um gerador de caracteres na RAM, etc. Atenção, o código não indica os nomes dos pinos do Arduino, mas os nomes dos pinos do microcontrolador de acordo com a folha de dados. Os nomes das saídas dos domadores de comparação são decifrados da seguinte forma: por exemplo, 2, B é OC2B, que no Arduino Uno corresponde ao PD3. Os exemplos mostram as opções de conexão que foram obtidas pelo autor.

Gere o arquivo de fonte clglcd_font.h com um script Python na pasta misc (veja acima).

Veja nos exemplos como inicializar, ligar e desligar a tela. Coloque na matriz da tela o texto que você deseja exibir para verificação.

Compile e preencha o esboço. Verifique com um analisador lógico se os sinais corretos vão para a tela e, com um voltímetro, todas as tensões de alimentação são normais. Somente então conecte o monitor.

Adicione um código ao esboço que fará algo, por exemplo, receba texto em uma porta serial e exiba-o.

Exibir interrupções

A exibição precisa ser atualizada constantemente, e é isso que os procedimentos de manipulação de interrupção fazem. Se as interrupções pararem por mais de 30 microssegundos, a tela piscará e, se mais de 60 microssegundos para uma unidade na linha FLM, ela poderá falhar. Se você precisar interromper as interrupções por um longo tempo, primeiro desligue a tela com o sinal DISPOFF (repito, este é um sinal inverso, o módulo é ligado de uma só vez). Obviamente, se ele desligar por dois segundos sempre que você precisar processar dados de um sensor de umidade e temperatura, poucos vão gostar, mas é melhor do que arruinar o módulo. Melhor ainda, carregue o restante em um microcontrolador separado. A troca de informações pelo mesmo microcontrolador com dispositivos operando no LED de protocolo e endereço de 1 fio é especialmente inaceitável. Os clones do Arduino Pro Micro são baratos o suficiente para comprar dois.

Comunicação

Mas as interfaces implementadas por hardware funcionarão perfeitamente: portas seriais, barramento I ² C, SPI no modo mestre. No escravo - somente se o mestre permitir "roll-off" periódico do escravo em 25-35 μs. Obviamente, ainda depende de quantas “pernas” permanecem desocupadas após conectar o monitor.

O USB no 32u4 funciona bem se você não interrogar o terminal de gerenciamento com muita frequência (código de rotina de interrupção lenta). O driver CDC e suas APIs foram rápidas o suficiente.

Em seguida, no arquivo README.md no GitHub, a lista de projetos semelhantes é repetida, da mesma forma que na página do projeto no Hackaday.io

Obrigado pela atenção!