alexandreschimel

Sex Jul 10, 2020 9:23 am
Solução alternativa para o Exercício da lição 22

O jogo Genius lançado no Brasil pela Estrela em 1980 foi uma febre imediata. Era possível encontrar desde o famoso disco colorido até robôs de um metro de altura que tinham o jogo no alto da cabeça.

No exercício proposto pela lição 22 do Kit Iniciante Arduino V8 o desafio de recriar o jogo é lançado aos alunos. Essa é a solução a que cheguei.

O jogo proposto abaixo tem as quatro cores do jogo original e algo da mecânica de um dos jogos que vinham carregados no jogo original. Aqui cabe a ressalva de que é o que eu me lembro da mecânica do jogo... eu tinha dez anos de idade na época (é, sou bem velho). Assim, posso estar muito enganado (e provavelmente estou) no que diz respeito à fidelidade ao jogo original. Porém, penso ter criado uma solução que é interessante e pode ser didática e divertida.

Ao iniciar o Arduino aguarda que você pressione qualquer botão e em seguida sorteia a primeira cor. Sua tarefa é pressionar o botão correspondente a essa cor. Se você acertar o Arduino emitirá um breve “bip” sinalizando o acerto, sorteará mais uma cor e apresentará a primeira e em seguida a segunda. Novamente, seu papel é pressionar os botões correspondentes às cores na mesma ordem que foram apresentados a você. Se você errar, três sons em sequência sinalizarão seu erro e você perdeu! O jogo volta ao estado inicial, aguardando o pressionamento de qualquer botão para iniciar um novo jogo.

Se você habilitar a janela da Saída Serial na IDE Arduino, você poderá acompanhar toda a mecânica interna do jogo acontecendo e poderá até “roubar” para ver o que acontece quando você vence.

A adição de cores à sequência continua enquanto você continuar acertando. Porém, a velocidade com que o Arduino te mostra a sequência toda vai aumentando.

Não há limite de tempo para sua resposta. O Arduino será paciente (pelo que me lembro, o Genius não era!)

Se você conseguir repetir vinte sequências com sucesso, você venceu o desafio. Sinais de comemoração serão emitidos pelos LEDs e pelo buzzer. Após isso, o jogo volta ao estado inicial aguardando você apertar qualquer botão para começar tudo novamente.

O limite de vinte sequências me parece um teto de hardware. Na apresentação da vigésima quarta o Arduíno trava.

Para montar o projeto você vai precisar dos seguintes itens:

01 x BlackBoard UNO R3
01 x Cabo USB AB
01 x Protoboard 400 pontos 
01 x LED Vermelho 5mm
01 x LED Verde 5mm
01 x LED RGB 5mm ou LED Azul 5mm
01 x LED Amarelo 5mm
04 x Chave Momentânea
01 x Buzzer Passivo 5V
04 x Resistor 300Ω
Jumpers

Circuito:
Monte todos os componentes conforme esquema abaixo. Conforme demonstrado, só a perna Azul e o Cátodo do LED RGB são usados de fato. Se você tiver um LED azul, basta montar como nos outros exemplos.

 


Código:
Carregue o código abaixo no Arduino:

Código:/*******************************************************************************
 * Kit Iniciante RoboCore: Projeto GENIUS
 * Exercício referente à aula 22
 * 
 * Simula o Jogo Genius que foi sucesso na década de 80
 * 
 * Alexandre Schimel
 * Última alteração: 09/07/2020
 ******************************************************************************/

// Declara os pinos dos botões
const int pinoBTVm = 12;
const int pinoBTVd = 10;
const int pinoBTAz = 7;
const int pinoBTAm = 5;

// Declara os pinos dos LEDs
const int pinoLEDVm = 13;
const int pinoLEDVd = 11;
const int pinoLEDAz = 8;
const int pinoLEDAm = 6;

// Declara o pino do Buzzer
const int pinoBuzzer = 9;

// Declara o pino para o randomSeed()
const float pinoA0 = A0;

// Declara as variáveis
int leBTVm, leBTVd, leBTAz, leBTAm,
    tempo = 1000, nivel = 0, sequencia[21],
    flagPerdeu = 0;

void setup() {
  // Define as funções dos pinos
  pinMode(pinoBTVm, INPUT_PULLUP);
  pinMode(pinoBTVd, INPUT_PULLUP);
  pinMode(pinoBTAz, INPUT_PULLUP);
  pinMode(pinoBTAm, INPUT_PULLUP);
  pinMode(pinoLEDVm, OUTPUT);
  pinMode(pinoLEDVd, OUTPUT);
  pinMode(pinoLEDAz, OUTPUT);
  pinMode(pinoLEDAm, OUTPUT);
  pinMode(pinoBuzzer, OUTPUT);
  pinMode(pinoA0, INPUT);
  // Inicializa a saída serial
  Serial.begin(9600);
}

int leBT(){
  // Lê os estados dos botões
  leBTVm = digitalRead(pinoBTVm);
  leBTVd = digitalRead(pinoBTVd);
  leBTAz = digitalRead(pinoBTAz);
  leBTAm = digitalRead(pinoBTAm);

  // Atribui um inteiro para cada leitura
  // As concatenações lógicas visam evitar permitir o pressionamento
  // de dois botões simultaneamente. 
  if (leBTVm == LOW && leBTVd == HIGH && leBTAz == HIGH && leBTAm == HIGH){
    return 1;
  }
  else if (leBTVm == HIGH && leBTVd == LOW && leBTAz == HIGH && leBTAm == HIGH){
    return 2;
  }
  else if (leBTVm == HIGH && leBTVd == HIGH && leBTAz == LOW && leBTAm == HIGH){
    return 3;
  }
  else if (leBTVm == HIGH && leBTVd == HIGH && leBTAz == HIGH && leBTAm == LOW){
    return 4;
  }
  else {
    return 0;
  }
}

void novoTom(){
  // Usa a leitura do pino (desconectado) A0 para o randomSeed()
  randomSeed((int)analogRead(pinoA0));  
  // Sorteia e atribui o resultado do sorteio
  // ao índice correto do array sequencias
  sequencia[nivel] = random(1, 5);  
}

void apagaLEDs(){
  digitalWrite(pinoLEDVm, LOW);
  digitalWrite(pinoLEDVd, LOW);
  digitalWrite(pinoLEDAz, LOW);
  digitalWrite(pinoLEDAm, LOW);
  noTone(pinoBuzzer);
}

void acendeLED(int LED){
  switch (LED){
  case 1:
    digitalWrite(pinoLEDVm, HIGH);
    tone(pinoBuzzer, 440.00);
    break;
  case 2:
    digitalWrite(pinoLEDVd, HIGH);
    tone(pinoBuzzer, 392.00);
    break;
  case 3:
    digitalWrite(pinoLEDAz, HIGH);
    tone(pinoBuzzer, 349.23);
    break;
  case 4: 
    digitalWrite(pinoLEDAm, HIGH);
    tone(pinoBuzzer, 329.63);
    break;
  default :
    return 0;
  }
  delay(150);
}

void apagaSeq(){
  int i;
  
  // Apaga os valores do array sequencias
  for (i = 0; sequencia[i] != NULL; i++){
    sequencia[i] = NULL;
  }  
}

void novoJogo(){
  int i;

  // Apaga todos os dados da sequencia
  apagaSeq();
  
  // Reinicia as variáveis de controle
  nivel = 0;
  tempo = 1000;
  flagPerdeu = 0;

  // Apaga todos os LEDs
  apagaLEDs();
  
  // Toca tone de novo jogo
  for (i = 0; i < 3; i++) {
    tone(pinoBuzzer, 329.63);
    delay(300);
    noTone(pinoBuzzer);
  }
  
  novoTom();
  tempo = 1000;
  Serial.println();
  Serial.println("NOVO JOGO!");
  Serial.println();
  delay(tempo);
}

void comemora(){
  acendeLED(1);
  delay(150);
  apagaLEDs();
  acendeLED(2);
  delay(150);
  apagaLEDs();
  acendeLED(3);
  delay(150);
  apagaLEDs();
  acendeLED(4);
  delay(150);
  apagaLEDs();  
}

void vitoria(){
  // Toca sinal de vitória
  tone(pinoBuzzer, 293.66);
  delay(300);
  tone(pinoBuzzer, 587.33);
  delay(200);
  tone(pinoBuzzer, 659.26);
  delay(500);
  noTone(pinoBuzzer);

  // Imprime Vitória! na saída serial
  Serial.println();
  Serial.println("Vitória!");
  Serial.println();
  
  // Pisca todos os LEDs indicando comemorando a vitória
  int i;
  for (i = 0; i < 3; i++) {
    comemora();
  }

  // Aguarda 1 segundo
  delay(1000);
}

void perdeu(){
  // Toca sinal de derrota
  tone(pinoBuzzer, 440.00);
  acendeLED(1);
  delay(400);
  noTone(pinoBuzzer);
  apagaLEDs();
  tone(pinoBuzzer, 415.30);
  acendeLED(1);
  delay(800);
  noTone(pinoBuzzer);
  apagaLEDs();
  tone(pinoBuzzer, 392.00);
  acendeLED(1);
  delay(600);
  noTone(pinoBuzzer);
  apagaLEDs();
  flagPerdeu = 1;
  apagaSeq();
  nivel = 0;
}

void loop() {
  // Declara as variáveis locais
  int i, entrada;
  
  // Aguarda que uma tecla seja pressionada para iniciar o jogo
  if (nivel == 0) {
    Serial.println("\nPressione qualquer botão para iniciar um jogo!");
    while(leBT() == 0) {};
    novoJogo();
  }

  // Imprime o Nível atual na saída serial
  Serial.print("Nivel: ");
  Serial.print(nivel);
  Serial.print("\t");
  Serial.print("Sequência Sorteada: ");
  
  // Toca a sequencia atual e imprime os valores na saída serial
  i = 0;
  for (i = 0; sequencia[i] != NULL; i++) {
    Serial.print(sequencia[i]);
    Serial.print(", ");
    acendeLED(sequencia[i]);
    delay(tempo);
    apagaLEDs();
  }
  Serial.println();

  // Aguarda cada entrada e verifica se está correta
  i = 0;
  for (i = 0; sequencia[i] != NULL; i++) {
    entrada = 0;
    while(entrada == 0) {
      entrada = leBT();
      if (entrada != 0) {
        acendeLED(entrada);
        delay(300);
        apagaLEDs();
      }
    };
    Serial.print("Cor Selecionada: ");
    Serial.print(entrada);
    Serial.print(", ");
    if (entrada == sequencia[i]) {
      Serial.print("Correto!\n");
    }
    else {
      Serial.println("\n\nCor errada! VOCÊ PERDEU!!!");
      perdeu();
    }
  }
  
  // Reduz o tempo de execução entre as notas a cada nível
  tempo -= 50;
  Serial.println();
  
  // Indicativo sonoro da mudança de nível
  delay(100);
  tone(pinoBuzzer, 698.46);
  delay(100);
  noTone(pinoBuzzer);
  delay(100);

  // Verifica se o nivel final (19) já foi atingido (totalizando 20 níveis)
  if (nivel < 19 && flagPerdeu == 0) {
    // Incrementa o nível do jogo
    nivel++;
  }
  else if (flagPerdeu == 1) {
    apagaSeq();
    nivel = 0;
  }
  else {
    // Se o nível final foi atingido
    // e o flagPerdeu ainda é 0, então:
    // O jogador venceu!
    vitoria();
    apagaSeq();
    nivel = 0;
  }
  novoTom();
}


Arquivos:
Arquivos com este texto, o projeto em Fritzing, e o código, podem ser acessados através desse link: https://1drv.ms/u/s!AgEVK...GIbU8A?e=wFEh7N

Genius.jpg Tamanho: 639.13 KB Downloads: 358 veze(s)

guibr907

Dom Nov 15, 2020 11:16 pm
Solução alternativa para o Exercício da lição 22

Genial 

brunodini

Qui Dez 17, 2020 1:17 pm
Solução alternativa para o Exercício da lição 22

Muito bom! Vou tentar, obrigado.

fs.rechia

Ter Nov 23, 2021 3:28 pm
Solução alternativa para o Exercício da lição 22

Também escrevi uma solução que reproduz o comportamento original, conforme eu lembrava do jogo. Iria postar aqui, mas a sua ficou muito mais detalhada, excelente!