Projeto 37 – Jogo do Ping Pong com LCD Nokia 5110

Projeto 37 – Jogo do Ping Pong com LCD 5110 

Olá pessoal, conforme prometido neste projeto iremos utilizar o módulo LCD Nokia 5110 para fazermos um jogo simples e muito conhecido - o ping pong. Eu utilizei dois joysticks como controle para controlar as barras, porém se vocês não tiverem este componente em mãos vocês podem utilizar potenciômetros que fará a mesma função do joystick. Então mãos aos componentes !!

Os códigos serão todos comentados para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!!

Vídeo do projeto pronto

Componentes necessários

1 Shield LCD Nokia 5110

1 Buzzer

2 Joysticks ou potenciômetros

1 Resistor de 220 Ω

Fios jumper do tipo macho/fêmea e macho/macho.

Conectando os componentes

Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. Agora, conecte todos componentes como mostra a figura abaixo:

Segue o esquemático abaixo para melhor entendimento:

Pinos do módulo LCD Nokia 5110               Pinos do Arduino

                       RST                                                       6

                       CE                                                         7

                       DC                                                         5

                       Din                                                         4

                       Clk                                                         3

                       Vcc                                                        5V

                       Gnd                                                       GND

                       BL                                                          Resistor (+)  

                                                         

Agora vamos ao código:

// Setando os pinos do LCD Nokia 5110 no Arduino Uno
#define PIN_SCE   7
#define PIN_RESET 6
#define PIN_DC    5
#define PIN_SDIN  4
#define PIN_SCLK  3

#define PIN_BUZZER 8

#define LCD_C     LOW
#define LCD_D     HIGH

// Inicializa o LCD com apenas 504 pixels de resolução.
#define LCD_X     84
#define LCD_Y     6

int barWidth = 14;  // Comprimento das barras.
int barHeight = 4;  // Largura das barras.
int ballPerimeter = 5;    // Tamanho da bola.
unsigned int bar1X = 0;
unsigned int bar1Y = 0;
unsigned int bar2X = 0;
unsigned int bar2Y = LCD_Y * 8 - barHeight;
int ballX = 0;
int ballY = 0;
boolean isBallUp = false;
boolean isBallRight = true;

byte pixels[LCD_X][LCD_Y];
unsigned long lastRefreshTime;
const int refreshInterval = 150;
byte gameState = 3; // Estágios do game.
byte ballSpeed = 4; // Velocidadeda bola.
byte player1WinCount = 0;
byte player2WinCount = 0;
byte hitCount = 0;

void setup(){  
  
  pinMode(PIN_BUZZER, OUTPUT);
  // Inicializa as funções abaixo.
  LcdInitialise();
  restartGame();
}

void loop(){    
  
  unsigned long now = millis();
  if(now - lastRefreshTime > refreshInterval){
      update();
      refreshScreen();
      lastRefreshTime = now;  
  }  
}


// Função reinciar jogo.
void restartGame(){
  
   ballSpeed = 1;
   gameState = 1;
   ballX = random(0, 60);
   ballY = 20;
   isBallUp = false; 
   isBallRight = true;
   hitCount = 0;
   
  }


// Função atualzar tela do LCD.
void refreshScreen(){

  if(gameState == 1){
    for(int y = 0; y < LCD_Y; y++){
        for(int x = 0; x < LCD_X; x++){
           byte pixel = 0x00;
           int realY = y * 8;
           
           // Inicia a bola na tela.
           if(x >= ballX && x <= ballX + ballPerimeter -1 && ballY + ballPerimeter > realY && ballY < realY + 8 ){
             byte ballMask = 0x00;
             for(int i = 0; i < realY + 8 - ballY; i++){
               ballMask = ballMask >> 1;
               if(i < ballPerimeter)
                 ballMask = 0x80 | ballMask;
             }
             pixel = pixel | ballMask;
           }
           
           // Inicia a barra na tela.
           if(x >= bar1X && x <= bar1X + barWidth -1 && bar1Y + barHeight > realY && bar1Y < realY + 8 ){
             byte barMask = 0x00;
             for(int i = 0; i < realY + 8 - bar1Y; i++){
               barMask = barMask >> 1;
               if(i < barHeight)
                 barMask = 0x80 | barMask;
             }
             pixel = pixel | barMask;
           }
           
           if(x >= bar2X && x <= bar2X + barWidth -1 && bar2Y + barHeight > realY && bar2Y < realY + 8 ){
             byte barMask = 0x00;
             for(int i = 0; i < realY + 8 - bar2Y; i++){
               barMask = barMask >> 1;
               if(i < barHeight)
                 barMask = 0x80 | barMask;
             }
             pixel = pixel | barMask;
           }
           LcdWrite(LCD_D, pixel);
         }
    }
  } else if(gameState == 2){
    // Faz a tratativa dos estágios do jogo.
    int pinOut = 8;
    int freq = 150;
    int duration = 1000;
    tone(pinOut, freq, duration);
  
  }
   
}

void update(){
    
  if(gameState == 1){
     int barMargin = LCD_X - barWidth;
     int joystick1 = analogRead(A0); // Lê os joysticks e posiciona as barras no LCD.
     int joystick2 = analogRead(A1);
     bar1X = joystick1 / 2 * LCD_X / 512;
     bar2X = joystick2 / 2 * LCD_X / 512;
    
     if(bar1X > barMargin) bar1X = barMargin;
     if(bar2X > barMargin) bar2X = barMargin;
     
     // Movimento da bola.
     if(isBallUp)
       ballY -= ballSpeed;
     else
       ballY += ballSpeed;
     if(isBallRight)
       ballX += ballSpeed;
     else
       ballX -= ballSpeed;
       
     // Verifica se ouve colisões.  
     if(ballX < 1){
       isBallRight = true;
       ballX = 0;
     }
     else if(ballX > LCD_X - ballPerimeter - 1){
       isBallRight = false;
       ballX = LCD_X - ballPerimeter;
     }
     if(ballY < barHeight){
       if(ballX + ballPerimeter >= bar1X && ballX <= bar1X + barWidth){ // Faz com que a bola ping para a barra 1.
         isBallUp = false;
         if(ballX + ballPerimeter/2 < bar1X + barWidth/2)
           isBallRight = false;
         else
           isBallRight = true;
         ballY = barHeight;
         if(++hitCount % 10 == 0 && ballSpeed < 5) 
           ballSpeed++;
       }else{   
         // Jogador 2 é o vencedor.
         gameState = 2;
         player2WinCount++;
       }
     }
     if(ballY + ballPerimeter > LCD_Y * 8 - barHeight){
       if(ballX + ballPerimeter >= bar2X && ballX <= bar2X + barWidth){ // Faz com que a bola ping para a barra 2.
         isBallUp = true; 
         if(ballX + ballPerimeter/2 < bar2X + barWidth/2)
           isBallRight = false;
         else
           isBallRight = true;
         ballY = LCD_Y * 8 - barHeight - ballPerimeter;
         if(++hitCount % 10 == 0 && ballSpeed < 5) 
           ballSpeed++;
       }
       else{ // Jogar 1 é o vencedor.
         gameState = 2;
         player1WinCount++;
       }
     }
  }else if(gameState == 2){
      for(int i =0; i < 4; i++){
        LcdWrite(LCD_C, 0x0D );  // LCD no modo inverso.
        delay(300);
        LcdWrite(LCD_C, 0x0C );  
        delay(300);
      }
      restartGame(); // Chama da função para resetar o game.
  }  
}

// Inicializa o LCD.
void LcdInitialise(void){  

  pinMode(PIN_SCE, OUTPUT);
  pinMode(PIN_RESET, OUTPUT);
  pinMode(PIN_DC, OUTPUT);
  pinMode(PIN_SDIN, OUTPUT);
  pinMode(PIN_SCLK, OUTPUT);
  delay(200);
  digitalWrite(PIN_RESET, LOW);
  delay(500);
  digitalWrite(PIN_RESET, HIGH);
  LcdWrite(LCD_C, 0x21 );  // Comandos ampliados do LCD.
  LcdWrite(LCD_C, 0xB1 );  // Configura o contraste do LCD. 
  LcdWrite(LCD_C, 0x04 );  // Configura o tempo de coeficiente.
  LcdWrite(LCD_C, 0x14 );  
  LcdWrite(LCD_C, 0x0C );  // LCD em modo normal.
  LcdWrite(LCD_C, 0x20 );
  LcdWrite(LCD_C, 0x80 ); 
  LcdWrite(LCD_C, 0x40 ); 
  LcdWrite(LCD_C, 0x0C );
}

void LcdWrite(byte dc, byte data){

  digitalWrite(PIN_DC, dc);
  digitalWrite(PIN_SCE, LOW);
  shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data);
  digitalWrite(PIN_SCE, HIGH);
}

Para confirmar se está tudo certo clique no botão Verify/Upload. Não havendo nenhum erro parabéns!! Agora divirta-se com este divertido jogo.

- Se você gostou do post, por favor comente! Nos dê um feedback, isto nos incentiva a continuar!

- Inscreva-se na fan page !

- Curta nossa fan page !

- Baixe o APP Faça Com Arduino e carregue para onde você for os projetos. É simples. É fácil !!

Continue lendo..

Projeto 25 – Gráfico de leitura de temperatura com um LCD Nokia 5110

Projeto 25 – Gráfico de leitura de temperatura com um LCD Nokia 5110

Olá pessoal, com o Nokia 5110 podemos fazer variarias coisas, como visualizar na tela imagens, textos e muito mais, irei mostrar como visualizar um gráfico de temperatura com este maravilhoso LCD juntamente com um sensor de temperatura LM35, deixando com uma visualização mais compreensível ao usuários. Os códigos serão todos comentados para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!!

Componentes necessários

1 Resistor de 220 Ω

1 Módulo Nokia 5110

1 Protobord

1 Sensor de temperatura LM35

Fios jumpers

Conectando os componentes

Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. Agora, conecte o módulo Nokia 5110, o LM35 e o resistor assim como mostra a figura abaixo:

Para melhor entendimento segue a inserção dos jumpers:

Pinos Arduino                                        Pinos LCD Nokia 5110

11                                                             RST

12                                                             CE

10                                                             DC

9                                                               Din

8                                                               Clk

5V                                                            Vcc

GND                                                         Gnd

Fazendo o download e importando a biblioteca do LCD Nokia 5110:

1)  Acesse o link https://onedrive.live.com/?cid=f877fded1de63faa#cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122 ;

2) Faça o download do arquivo PCD8544;

3) Descompacte o arquivo;

4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie o arquivo descompactado nesta pasta;

5) Pronto para utilizar;

Agora vamos ao código

                                                          

// Projeto 25 – Gráfico de leitura de temperatura com um LCD Nokia 5110

#include <PCD8544.h>  // Biblioteca utilizada para controle de gráficos e/ou desenhos.

static const byte SensorTemp = 0;  // Pino analógico onde está o LM35.

// Definindo as dimensões do LCD (em pixels).

static const byte LCD_WIDTH = 84;

static const byte LCD_HEIGHT = 48;

// Define o número de linhas para exibir o caracter de temperatura.

static const byte CHART_HEIGHT = 5;

// Define o símbolo gráfico para ser exibido no LCD.

static const byte DEGREES_CHAR = 1;

static const byte degrees_glyph[] = { 0x00, 0x07, 0x05, 0x07, 0x00 };

// Uma imagem bitmap gráfica de 10X2 do termômetro.

static const byte THERMO_WIDTH = 10;

static const byte THERMO_HEIGHT = 2;

static const byte thermometer[] = { 0x00, 0x00, 0x48, 0xfe, 0x01, 0xfe, 0x00, 0x02, 0x05, 0x02,

                                    0x00, 0x00, 0x62, 0xff, 0xfe, 0xff, 0x60, 0x00, 0x00, 0x00};

static PCD8544 lcd;

void setup() {

  lcd.begin(LCD_WIDTH, LCD_HEIGHT);

 

  // Registra o símbolo personalizado do termômetro.

  lcd.createChar(DEGREES_CHAR, degrees_glyph);

 

   /* A referência 1.1V interno prevê uma melhor

    Resolução do LM35, e também é mais estável

    Quando alimentado a partir de uma entrada USB. */

   

  analogReference(INTERNAL);

}

void loop() {

 

  // Define a borda do LCD.

  static byte xChart = LCD_WIDTH;

 

  // Lê a temperatura em graus Celsius.

  float SensorTemp = (1.1 * analogRead(SensorTemp) * 100.0) / 1024.0;

 

  // Imprime a temperatura na tela do LCD.

  lcd.setCursor(0, 0);

  lcd.print("Temp: ");

  lcd.print(SensorTemp, 1);

  lcd.print(" \001C ");

  // Desenhar o bitmap termômetro no canto inferior esquerdo ...

  lcd.setCursor(0, LCD_HEIGHT/8 - THERMO_HEIGHT);

  lcd.drawBitmap(thermometer, THERMO_WIDTH, THERMO_HEIGHT);

  // Define a posição do gráfico.

  if (xChart >= LCD_WIDTH) {

    xChart = THERMO_WIDTH + 2;

  }

  // Atualiza o gráfico de temperatura. 

  lcd.setCursor(xChart, 1);

  lcd.drawColumn(CHART_HEIGHT, map(SensorTemp, 0, 45, 0, CHART_HEIGHT*8));  // Define uma faixa entre 0 - 45°C

  lcd.drawColumn(CHART_HEIGHT, 0);  // Define uma posição correta do gráfico.

 

  xChart++;

  delay(500);

}

Para certificar se o código está correto pressione o botão Verify/Compile.

Se tudo estiver correto pressione o botão Upload para fazer o upload do código para seu Arduino.

Se tudo estiver OK você verá na tela a temperatura real, juntamente com um gráfico que irá mudar de acordo com a temperatura.

Vídeo do projeto pronto:

- Se você gostou do post, por favor comente! Nos dê um feedback, isto nos incentiva a continuar! :)

- Inscreva-se na fan page !

- Curta nossa fan page !

- Baixe o APP Faça Com Arduino e carregue para onde você for os projetos. É simples. É fácil !!

Continue lendo..