Projeto 38 - Jogo dos caminhões com LCD 16X2

  • Janeiro 14, 2015
  • Comentários

Olá pessoal, para quem não tem um LCD nokia 5110 também pode fazer jogos muito legais com um LCD 16X2. Este jogo consiste em desviar dos caminhões, evitando assim as colisões. Parece ser fácil, porém a velocidade vai aumentando e a colisão é certeira!! Para movermos o carrinho para baixo e para cima dispomos de um potenciômetro como controle. Então vamos ao trabalho. 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 Protoboard

1 LCD 16X2

1 Buzzer

2 Potenciômetros

Fios jumper

Obs.: Você pode utilizar mais de um potenciômetro para controle de brilho (Verifique o post Projeto 10 - Controle de temperatura com LCD e cooler )

Conectando os componentes

Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. Agora, pegue a protoboard, o LCD, o buzzer, os potenciômetros e os fios jumpers e conecte-os assim como mostra a figura abaixo:

Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, desde que os componentes e os fios estejam conectados na mesma ordem da figura. Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode resultar em danos. Certifique-se de que todos os componentes estejam conectados corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue seu Arduino conectando-o ao cabo USB.

Código do projeto

// Projeto 38 -  Jogo dos caminhões com LCD 16X2

// Declarando a biblioteca para comunicação com o LCD.
#include <LiquidCrystal.h> 

LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Declarando os pinos a serem usados.
const int POTPIN = 1;  // Potenciometro no pino A1 do Arduino

// Precisamos girar todo o potenciometro para o carrinho subir e... 
//descer no visor do LCD.
const int MAXPOT = 1024; 

// Declara o pino digital 10 para acionar o Speaker.
const int SPEAKERPIN = 10;  

// Um pino analogico que não esta conectado a nada.
const int RANDSEEDPIN = 0; 

// Inicia devagar e a cada milisegundos vai aumetando a velocidade...
const int MINSTEPDURATION = 150; 

// Até chegar ao máximo de sua velocidade.
const int MAXSTEPDURATION = 300; 
const int NGLYPHS = 6;
byte glyphs[NGLYPHS][8] = {  // Iremos criar os carros e caminhões...

  // Imagem carro para cima.
  { B00000,
    B01110,
    B11111,
    B01010,
    B00000,
    B00000,
    B00000,
    B00000}

  // Imagem carro para baixo.
  ,{B00000,
    B00000,
    B00000,
    B00000,
    B01110,
    B11111,
    B01010,
    B00000}

  // Imagem do caminhão para cima.
  ,{B00000,
    B11110,
    B11111,
    B01010,
    B00000,
    B00000,
    B00000,
    B00000}

  // Imagem do caminhão para baixo.
  ,{B00000,
    B00000,
    B00000,
    B00000,
    B11110,
    B11111,
    B01010,
    B00000}

  // Imagem de batida para cima.
  ,{B10101,
    B01110,
    B01110,
    B10101,
    B00000,
    B00000,
    B00000,
    B00000}

  // Imagem de batida para baixo.
  ,{B00000,
    B00000,
    B00000,
    B10101,
    B01110,
    B01110,
    B10101,
    B00000}

};

const int NCARPOSITIONS = 4;

const char BLANK=32;

char car2glyphs[NCARPOSITIONS][2] = {

  {1,BLANK},{2,BLANK},{BLANK,1},{BLANK,2}

};

char truck2glyphs[NCARPOSITIONS][2] = {

  {3,BLANK},{4,BLANK},{BLANK,3},{BLANK,4}

};

char crash2glyphs[NCARPOSITIONS][2] = {

  {5,BLANK},{6,BLANK},{BLANK,5},{BLANK,6}

};

const int ROADLEN = 15; // Largura do LCD (sem contar nosso carro).

int road[ROADLEN]; // Posição dos outros carros.

char line_buff[2+ROADLEN]; 

int road_index;

int car_pos;

// Off-the-grid posição significa coluna vazia, então MAXROADPOS

 // Determina a probabilidade de um carro numa coluna

 // Por exemplo 3 * NCARPOSITIONS dá p = 1/3

const int MAXROADPOS = 3*NCARPOSITIONS;

int step_duration;

int crash; // Verdadeiro se haver colisão.

unsigned int crashtime;

const int CRASHSOUNDDURATION = 250;



const char *INTRO1="OlhePARAfrente";

const char *INTRO2="Tenha cuidado";

const int INTRODELAY = 2000; // Introdução com duração de dois segundos.

void setup()

{

  crash = crashtime = road_index = 0;

  step_duration = MAXSTEPDURATION;

  line_buff[1+ROADLEN] = '\0';

  randomSeed(analogRead(RANDSEEDPIN));

  for (int i=0; i<NGLYPHS; i++) {

    lcd.createChar(i+1,glyphs[i]);

  }

  for (int i=0; i<ROADLEN; i++) {

    road[i]=-1;

  }

  pinMode(SPEAKERPIN,OUTPUT);  // Define pino 10 com de saída.

  analogWrite(SPEAKERPIN,0); // Para estar no lado seguro.

  lcd.begin(16,2);  // Inicia o LCD de 16X2.

  getSteeringWheel();

  drawRoad();

  lcd.setCursor(1,0); // Na primeira coluna e linha 0...

  lcd.print(INTRO1);  // Imprima "CaminhoeAfrente".

  lcd.setCursor(1,1); // Na primeira coluna linha 1...

  lcd.print(INTRO2); // Imprima "Tenha cuidado".

  delay(INTRODELAY); // Aguarda 2 segundos antes de começar o jogo.

}

void loop() {

  unsigned long now = millis()-INTRODELAY;

  if (!crash) {

    getSteeringWheel();

    crash = (car_pos==road[road_index]);

  }

  if (crash) {

    if (!crashtime) {

      crashtime=now;

      drawRoad();

      lcd.setCursor(2,0); // Na coluna 2 lina 0...

      lcd.print("Grave colisao!!"); // Imprima "Grave colisão!!".

      lcd.setCursor(2,1);

      lcd.print(now/1000);

      lcd.print(" segundos.");

    }

    if ((now-crashtime)<CRASHSOUNDDURATION) {

      analogWrite(SPEAKERPIN,random(255)); 

    } 

    else {

      analogWrite(SPEAKERPIN,0); // Havendo colisão ouvimos um som... 
	  //pelo Speaker...   

    }

    delay(10); // De 10 milisegundos.

  } 

  else {

    int prev_pos = road[(road_index-1)%ROADLEN];

    int this_pos = random(MAXROADPOS);

    while (abs(this_pos-prev_pos)<2) { 

      this_pos = random(MAXROADPOS);

    }

    road[road_index] = this_pos;

    road_index = (road_index+1)%ROADLEN;

    drawRoad();

    delay(step_duration); // Delay de 300 milisegundos.
    
    if (step_duration>MINSTEPDURATION) {

      step_duration--; 

    }

  }

}

void getSteeringWheel() {

  car_pos = map(analogRead(POTPIN),0,1024,0,NCARPOSITIONS);

}void drawRoad() {

  for (int i=0; i<2; i++) {

    if (crash) {

      line_buff[0]=crash2glyphs[car_pos][i];

    } 

     else {

      line_buff[0]=car2glyphs[car_pos][i];

    }

  for (int j=0; j<ROADLEN; j++) {

  int pos = road[(j+road_index)%ROADLEN];

  line_buff[j+1]= pos>=0&&pos>NCARPOSITIONS?truck2glyphs[pos][i]:BLANK;

    }

    lcd.setCursor(0,i);

    lcd.print(line_buff);

  }

}

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. Pronto, agora ajuste o contraste do seu LCD girando o potenciômetro correspondente. O jogo irá começar em breve, quando isso acontecer gire o potenciômetro para o carrinho subir e descer afim de desviar dos caminhões. Boa diversão!!!

Vídeo do projeto pronto

Obs.: Quando você colidir com algum dos caminhões, reset o jogo pressionando o botão de reset de seu Arduino.

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

- Curta nossa fan page!



Deixe seu comentário abaixo