Animação de LCD e jogos

Componentes e suprimentos

Arduino UNO

LCD alfanumérico, 16 x 2

Aplicativos e serviços online

Arduino IDE

Sobre este projeto

Este projeto enfoca os fundamentos da animação usando arduino e um lcd 16 por 2. No entanto, este projeto também pode ser estendido para lcds de outras dimensões.

Primeiro, começaremos com a fiação do lcd para o arduino e, em seguida, com a impressão simples de uma mensagem para o lcd. Em seguida, passaremos para a animação.

Fiação do LCD

Este é o circuito mostrado nos diagramas acima.

PIN do LCD

1:VSS:ao trilho positivo da placa de ensaio (conecte 5v do Arduino ao trilho positivo também)

2:VDD:para o trilho negativo da placa de ensaio (conecte o GND do Arduino aqui também)

3:VO (contraste):para limpar o potenciômetro (anexar os terminais laterais do potenciômetro aos trilhos positivos e negativos)

4:RS (seleção de registro):para Arduino pino 12

5:R / W (leitura-gravação):para trilho negativo

6:E (habilitar):para o pino 11 do Arduino

15:A (ânodo):para trilho positivo com resistência de 220 ohm

16:K (cátodo):para trilho negativo

Não iremos anexar pin de dados agora.

Ligue a alimentação e, se a linha inferior acender, o lcd está funcionando. Você deve testar isso antes de começar a fazer qualquer outra coisa.

Se o lcd não acender, verifique a solda, a fiação (verifique novamente) e se ainda assim não acender, é altamente provável que o lcd esteja corrompido, portanto, é necessário substituí-lo.

Se o seu lcd funcionar, Bravo! você terminou a primeira parte deste tutorial.

Depois disso, conecte os pinos de dados:

11:D4 (pino de dados 4):para o pino 4 do Arduino

12:D5:para o pino 5 do Arduino

13:D6:para Arduino pino 6

14:D7:para Arduino pino 7

Após este código de amostra de upload

  #include  LiquidCrystal lcd (12,11,4,5,6,7); // rs, e, d4, d5, d6, d7 respectivamentevoid setup () {lcd.begin (16,2); lcd.setCursor (0,1); lcd.print ("Trabalhando");} void loop () {}

Depois de fazer o upload, se você vir caracteres aleatórios ou nada, verifique o contraste (gire o dial do potenciômetro para cima e para baixo), verifique a solda do pino (os pinos de dados NÃO devem ser conectados um ao outro nem mesmo ligeiramente) e, finalmente, o circuito e a linha 2 em o código de amostra (certifique-se de que os números dos pinos fornecidos ao LiquidCrystal correspondem aos do seu circuito.

Se ainda não acontecer nada, não perca as esperanças, se você viu a linha inferior acender na primeira parte, isso significa que sua tela de lcd está OK. brinque com o circuito e a solda até que funcione.

Se você vir a mensagem "Trabalhando", significa que conectou seu lcd com sucesso e concluiu a segunda parte deste tutorial. Deixe seu circuito como está, não vamos mexer mais com ele, tudo o que temos que fazer agora será no software.

Explicação do Código na Parte 2

LiquidCrystallcd (12,11,4,5,6,7);

Esta linha declara um objeto LCD com pinos de interface, conforme fornecido nos argumentos. Agora, toda a interface do lcd será feita por meio desse objeto 'lcd' (observe que você pode nomear o que quiser, mas manter esse nome o tempo todo).

lcd.begin (16,2);

Esta linha declara que nossa tela de lcd tem 16 colunas e 2 linhas, observe que seu lcd não pode ter 16 por 2, ajuste os números de acordo.

lcd.setCursor (0,1);

Esta linha colocará o cursor na primeira coluna e na segunda linha (já que a contagem em C ++ começa com 0 e não 1!). Observe que você não pode ver o cursor, mas o cursor está sempre lá, ele fixa o local em que o próximo caractere aparecerá.

lcd.print ("Bem-vindo");

Esta linha irá imprimir a mensagem Bem-vindo no local em que o cursor está apontando, ou seja, 0 colunas 1 linha.

Texto de rolagem

Bem, imprimimos uma mensagem na tela, mas não é muito atraente ficar sentado olhando aquela mesma mensagem, além do mais não adianta nada. Assim, nesta seção iremos imprimir uma mensagem que irá rolar da direita para a esquerda como nos quadros de anúncios. Apenas as funções setup () e loop () serão diferentes, portanto, estou mostrando apenas essas funções, o resto permanece o mesmo.

  void setup () {lcd.begin (16,2);} void loop () {int n; char mensagem [] ="texto de rolagem!"; n =15; char * ptr =mensagem; enquanto (n! =- 14) {lcd.clear (); lcd.setCursor (n, 1); se (n <0) {ptr ++; } lcd.print (ptr); n -; atraso (250);}}

Observe que para entender esse código, você precisa de um bom conhecimento de ponteiros em C e C ++, já que a linguagem Arduino é, na verdade, apenas AVR-C ++, apenas levemente processada.

Na função de loop, estamos definindo sua mensagem como uma string constante.

lcd.clear () é usado para limpar a tela a cada iteração.

Em seguida, definimos um ponteiro ptr para conter o endereço da mensagem. Este valor do ponteiro será incrementado para caber na mensagem na janela do lcd mesmo depois que os caracteres saírem de vista para a esquerda. Fazemos isso para a extremidade esquerda e não para a direita, já que a biblioteca LiquidCrystal pode lidar com isso para a extremidade direita (texto rolando para fora), mas não pode lidar com endereços de colunas negativas como é necessário para nosso programa.

Em seguida, temos um loop while que exibirá a mensagem em vários locais da esquerda para a direita, dando a ilusão de que o texto está se movendo. Observe que o atraso () no final é para garantir que possamos ler o texto e que ele não gire da direita para a esquerda em velocidades ilegíveis. Se a animação parecer muito lenta ou muito rápida, você pode alterar o valor do atraso.

Caracteres personalizados

Para todos os usos da função lcd.print (), não podemos exibir, digamos um dinossauro, na tela de lcd. No entanto, podemos fazer isso usando um recurso da biblioteca LiquidCrystal chamado caracteres personalizados.

Para isso definimos um byte de dados, que contém 1s para todos os pixels ligados e 0s para todos os pixels desligados, assim:

  byte dino [] ={B01110, B01110, B01100, B01111, B11101, B01010, B01010, B01010}

Este é um caractere personalizado, que exibirá um dinossauro na tela LCD. Você pode criar seus próprios personagens aqui:https://maxpromer.github.io/LCD-Character-Creator/

Depois disso, precisamos exibi-los. No entanto, esses caracteres não podem ser exibidos usando o método lcd.print normal; precisamos usar isso:

  void setup () {lcd.createChar (0, dino); lcd.begin (16,2); lcd.setCursor (0,1); lcd.write (byte (0));}

Com esse código, criamos um caractere endereçável personalizado a partir de nosso byte dino [] definido por arlier. O endereço do nosso personagem personalizado é fornecido pelo método lcd.createChar (), que define o caractere 0 como dino []. Em seguida, nos referiremos a esse caractere como byte (0), que retorna o endereço de nosso caractere personalizado e, finalmente, o imprime na tela usando o método lcd.Write ().

Arremessar flechas

Este programa finalmente ensinará como animar usando telas lcd, leia com atenção.

  #include  LiquidCrystal lcd (12,11,4,5,6,7); ponta de seta de byte [] ={B00001, B00011, B00111, B01111, B00111, B00011, B00001, B00000 } byte arrowbody [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000} byteB00011, B00111, B01111, B11111, B11111, B01111, B00111, B00011} voidlcd.createChar); createChar (1, arrowbody); lcd.createChar (2, arrowtail); lcd.begin (16,2);} voidintwhile (n! =- 1) {lcd.clear (); lcd.setCursor (0,1); lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); n -; atraso (50);}}

Aqui, usamos três caracteres personalizados para simular uma flecha. O resto é familiar para você. Ao executar isso em seu LCD, você pode notar uma trilha atrás da ponta da flecha, fazendo com que pareça mais longa do que é, não se preocupe, é apenas o resíduo da posição anterior da flecha.

É isso! Você terminou sua primeira animação com Arduino e LCDs! Brinque com o código e combine-o com entradas de botão para transformá-lo em um jogo completo!

Jogo LCD

Finalmente podemos fazer um jogo! No entanto, durante este tutorial, não vou começar com um jogo muito complicado, mas um jogo muito simples, bastante semelhante aos primeiros jogos de arcade.

Objetivo deste jogo

Antes de começarmos o jogo, precisamos descobrir um objetivo para a jogabilidade.

Neste jogo, o objetivo é o seguinte:

Existe o herói, uma pessoa na linha 1 (observe que a primeira linha é a linha 0) (normalmente) em quem uma série de flechas serão disparadas. Se o herói for atingido, o jogo acaba. O herói vai evitar as setas saltando para a linha 0, que vamos manipular por meio de um botão. (pressionar o botão =linha 0, não =linha1). A pontuação é incrementada por loop e exibida no canto direito.

Esta é na verdade uma extensão da animação das setas anteriores, portanto, incluirei apenas as partes que foram alteradas.

  byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; void setup () {// configurar o número de colunas e linhas do LCD:lcd.createChar ( 0, ponta de seta); lcd.createChar (1, corpo em seta); lcd.createChar (2, flecha); lcd.createChar (3, homem); lcd.begin (16, 2); attachInterrupt (0, buttonin, CHANGE); randomSeed (analogRead (A0)); // Imprime uma mensagem no LCD. //lcd.print("hello, world! ");} int n; void loop () {// definir o cursor para a coluna 0, linha 1 // (nota:a linha 1 é a segunda linha, já que a contagem começa com 0)://lcd.setCursor(0, 1); // imprime o número de segundos desde a reinicialização://lcd.print (millis () / 1000); n =15; int rnd; rnd =aleatório (15,25); enquanto (n! =- 1) {lcd.clear (); atraso (10); drawman (); lcd.setCursor (n, 1); if (n ==1) {if (nível ==1) {stopgame (); Prosseguir; }} lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); lcd.setCursor (10,0); lcd.print (pontuação); atraso (100-rnd); n--; pontuação ++; if (nível ==0) pontuação--; }} void drawman () {lcd.setCursor (1, nível); lcd.write (byte (3));} void buttonin () {if (digitalRead (2) ==LOW) {level =0; } mais {nível =1; }} void stopgame () {lcd.clear (); lcd.setCursor (0,0); lcd.print ("Fim do jogo"); lcd.setCursor (10,0); lcd.print (pontuação); nível =1; pontuação =0; n =15; atraso (3000); return;}

Nem todo esse código é sobre o LCD, mas TUDO é importante para o desenvolvimento de jogos.

Começamos com a definição do personagem man [] que irá armazenar o byte para o personagem man (nosso herói). Então temos a função de configuração, onde apenas duas linhas foram alteradas. Ambas as linhas são representativas de apenas uma parte do vasto grupo em que se inserem, a saber, interrupções e números aleatórios. Ambos são comodidades muito úteis, mais informações sobre as quais você pode encontrar no site arduino.cc.

Primeiro, temos a função attachInterrupt. Observe que a definição que vou dar não é muito abrangente, mas é necessária uma curta para entender o que está acontecendo aqui.

As interrupções são funções que podem ser acionadas na ocorrência de um evento, NÃO IMPORTA ONDE A EXECUÇÃO está ocorrendo. Este é um fato importante, útil para implementar funções de entrada em tempo real. Aqui, nós o usamos para ter certeza de que não importa em que ponto da execução o botão é pressionado, nós tomaremos a ação apropriada (pelo menos o programa o fará).

Sintaxe para attachInterrupt:

attachInterrupt (pin_number-2, function_to_call_without_parenthesis, condition_for_calling);

CHANGE é um valor #define usado para significar que para qualquer mudança no estado na entrada pin_number a função anexada será chamada.

Então temos um número aleatório. Uma excelente qualidade que os processadores físicos como o Arduino possuem, que os processadores normais não possuem, é que um número aleatório gerado pelo Arduino é verdadeiramente aleatório como o ruído analógico presente no pino A0 se pino A0 está flutuando (ou seja, desconectado) é aleatório, conforme previsto pela física quântica (mais ou menos).

randomSeed é usado para definir a semente para o processo aleatório. random () é uma função com parâmetros MIN, MAX ou MAX apenas para obter o próximo número aleatório na sequência.

Então temos a função de interrupção buttonin () que verifica se o botão está pressionado (LOW) ou não (HIGH) e muda o nível (linha) de nosso herói de acordo.

É isso, temos um jogo totalmente funcional !!

Código

código para animação
código para o jogo

código para animação Arduino

 // inclua o código da biblioteca:#include  // inicialize a biblioteca associando qualquer pino de interface LCD necessário // com o número do pino Arduino que está conectado toconst int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7; LiquidCrystal lcd (rs, en, d4, d5, d6, d7); ponta de seta de byte [] ={B00001, B00011, B00111, B01111, B00111, B00011, B00001 , B00000}; byte arrowtail [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000}; byte arrowtail [] ={B00011, B00111, B11111, B11111, B11111, B00111, B00011, B00000}; byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; void setup () {// configurar o número de colunas e linhas do LCD:lcd.createChar (0, ponta de seta); lcd.createChar (1, corpo em flecha); lcd.createChar (2, flecha); lcd.createChar (3, homem); lcd.begin (16, 2); // Imprime uma mensagem no LCD. //lcd.print("hello, world! ");} void loop () {// definir o cursor para a coluna 0, linha 1 // (nota:a linha 1 é a segunda linha, já que a contagem começa com 0)://lcd.setCursor(0, 1); // imprime o número de segundos desde a reinicialização://lcd.print (millis () / 1000); int n; n =15; enquanto (n! =- 1) {lcd.clear (); atraso (10); lcd.setCursor (0,0); lcd.print ("por Debanshu Das"); / * lcd.setCursor (1,1); lcd.write (byte (3)); lcd.setCursor (n, 1); lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); * / atraso (65); n--; }}

código para o jogo Arduino

 // inclua o código da biblioteca:#include  // inicialize a biblioteca associando qualquer pino de interface LCD necessário // com o número do pino Arduino que está conectado toconst int rs =12, en =11, d4 =4, d5 =5, d6 =6, d7 =7; LiquidCrystal lcd (rs, en, d4, d5, d6, d7); nível interno =1; pontuação interna =0; ponta de seta de byte [] ={B00001, B00011 , B00111, B01111, B00111, B00011, B00001, B00000}; byte arrowbody [] ={B00000, B00000, B00000, B11111, B11111, B00000, B00000, B00000}; byte arrowtail [] ={B00011, B00111, B11111, B11111 , B11111, B00111, B00011, B00000}; byte man [] ={B01110, B01110, B00100, B01110, B10101, B00100, B01010, B10001}; configuração vazia () {// configurar o número de colunas e linhas do LCD:lcd.createChar (0, ponta de seta); lcd.createChar (1, corpo em seta); lcd.createChar (2, flecha); lcd.createChar (3, homem); lcd.begin (16, 2); attachInterrupt (0, buttonin, CHANGE); randomSeed (analogRead (A0)); // Imprime uma mensagem no LCD. //lcd.print("hello, world! ");} int n; void loop () {// definir o cursor para a coluna 0, linha 1 // (nota:a linha 1 é a segunda linha, já que a contagem começa com 0)://lcd.setCursor(0, 1); // imprime o número de segundos desde a reinicialização://lcd.print (millis () / 1000); n =15; int rnd; rnd =aleatório (15,25); enquanto (n! =- 1) {lcd.clear (); atraso (10); drawman (); lcd.setCursor (n, 1); if (n ==1) {if (nível ==1) {stopgame (); Prosseguir; }} lcd.write (byte (0)); lcd.write (byte (1)); lcd.write (byte (2)); lcd.setCursor (10,0); lcd.print (pontuação); atraso (100-rnd); n--; pontuação ++; if (nível ==0) pontuação--; }} void drawman () {lcd.setCursor (1, nível); lcd.write (byte (3));} void buttonin () {if (digitalRead (2) ==LOW) {level =0; } mais {nível =1; }} void stopgame () {lcd.clear (); lcd.setCursor (0,0); lcd.print ("Fim do jogo"); lcd.setCursor (10,0); lcd.print (pontuação); nível =1; pontuação =0; n =15; atraso (3000); return;}

Esquemas

Smart Blinds Arduino Due TIC TAC TOE com tela sensível ao toque

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial