Assista no YouTube

Tutoriais ESP32 36/55 - Jogo de Adivinhação de Números | Kit de Aprendizado IoT ESP32 da SunFounder

Neste tutorial, vamos criar um divertido jogo de adivinhação de números usando o microcontrolador ESP32 junto com um controle remoto infravermelho e um display LCD. O jogador tentará adivinhar um número gerado aleatoriamente entre 0 e 99, com o jogo fornecendo dicas sobre se o palpite é muito alto ou muito baixo. Através deste projeto, você aprenderá como usar o receptor infravermelho, exibir valores em um LCD e gerenciar a entrada do usuário a partir de um controle remoto. Você pode se referir ao vídeo para maior clareza (no vídeo em 00:00).

Hardware Explicado

Os componentes principais utilizados neste projeto incluem o microcontrolador ESP32, um controle remoto infravermelho, um receptor infravermelho e um display LCD. O ESP32 serve como a unidade de processamento principal e é capaz de gerenciar comunicação sem fio, tornando-se uma escolha versátil para projetos de IoT. O controle remoto infravermelho permite que os usuários insiram palpites sem exigir interação física com a placa, enquanto o LCD exibe o status do jogo e os avisos.

O receptor infravermelho detecta sinais do controle remoto e os decodifica para uso no jogo. Cada pressionamento de botão no controle corresponde a um valor específico que o ESP32 pode interpretar. O display LCD fornece uma interface visual para o usuário, mostrando a faixa de palpite atual e se o palpite estava correto.

Detalhes da Ficha Técnica

• Certifique-se de que todos os componentes sejam classificados para 3,3 V e 5 V, quando aplicável.
• Use resistores de pull-up adequados para o receptor IR para evitar entradas flutuantes.
• Considere usar um dissipador de calor se estiver operando na corrente máxima de saída por períodos prolongados.
• Ao usar PWM, mantenha uma frequência em torno de 1 kHz para desempenho ideal.
• Tenha cuidado com a fiação; assegure-se de que as conexões estão seguras para evitar falhas intermitentes.

Instruções de fiação

Para configurar a fiação para o jogo de adivinhação de números, comece conectando o receptor infravermelho. Conecte o fio vermelho do pino direito do receptor à fonte de alimentação de 3,3 V no ESP32. O fio preto deve ir para o terra, enquanto o pino da esquerda do receptor infravermelho se conecta ao pino14no ESP32.

Em seguida, conecte o display LCD. Conecte o pino VCC do LCD à fonte de 5 V no ESP32 e o pino de terra ao terra. Os pinos SDA e SCL do LCD devem ser conectados aos pinos21e22respectivamente. Certifique-se de que haja dois espaços vazios entre as conexões SDA e SCL para evitar conflitos de pinos. Por fim, certifique-se de remover quaisquer capas de plástico da bateria antes de ligar a placa.

Exemplos de Código e Tutorial

Os seguintes trechos de código ilustram partes essenciais do programa utilizado para o jogo de adivinhação de números. Começamos incluindo bibliotecas necessárias e definindo identificadores chave.

#include 
#include 
#include 
#include 

const uint16_t IR_RECEIVE_PIN = 14;
IRrecv irrecv(IR_RECEIVE_PIN);
decode_results results;

Neste excerto, incluímos bibliotecas para lidar com a funcionalidade do LCD e do receptor de infravermelho. O pino para o receptor de infravermelho é definido como14, e criamos instâncias dos objetos necessários para gerenciar a entrada e a saída.

void setup() {
  lcd.init();
  lcd.backlight();
  Serial.begin(9600);
  irrecv.enableIRIn();
  initNewValue();
}

Este trecho mostra a função de configuração onde inicializamos o LCD, começamos a comunicação serial e habilitamos o receptor IR. A funçãoinitNewValue()é chamado para gerar um novo número aleatório para o jogador adivinhar.

bool detectPoint() {
  if (count > pointValue) {
    if (count < upper) upper = count;
  } else if (count < pointValue) {
    if (count > lower) lower = count;
  } else if (count == pointValue) {
    count = 0;
    return 1;
  }
  count = 0;
  return 0;
}

Esta função verifica o palpite do jogador em relação ao número gerado aleatoriamente, ajustando os limites superior e inferior de acordo. Se o palpite estiver correto, redefine a contagem e retorna verdadeiro.

O código completo está carregado abaixo do artigo para sua referência.

Demonstração / O Que Esperar

Uma vez que tudo esteja conectado e o código carregado, o jogo irá solicitar que você pressione qualquer número no controle remoto. O jogo então fornecerá feedback sobre suas palpites, atualizando a faixa de números possíveis até que você acerte o número-alvo. Se você pressionar o botão POWER, o jogo reinicia e começa novamente (no vídeo em 02:30).

Os erros comuns incluem garantir que o receptor de infravermelho esteja devidamente orientado e que todas as conexões estejam seguras. Se o jogo não responder, verifique a fonte de energia e confirme se a placa e a porta corretas estão selecionadas no Arduino IDE.

Marcadores de Tempo do Vídeo

• 00:00 Iniciar
• 2:17 Introdução ao projeto do jogo
• 4:37 Fiação
• 6:15 Código do Arduino explicado
• Selecionando a Placa ESP32 e a Porta COM no Arduino IDE
• 16:16 Jogando jogo de adivinhação de números

Imagens

ESP32_36_guessing_number_schematic

ESP32_36_guessing_number_wiring

ESP32_36_guessing_numbe-1

ESP32_36_guessing_numbe-2

ESP32_36_guessing_number_schematic

ESP32_36_guessing_number_wiring

ESP32_36_guessing_numbe-1

ESP32_36_guessing_numbe-2

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <IRremoteESP8266.h>
#include <IRrecv.h>

// Define the IR receiver pin
const uint16_t IR_RECEIVE_PIN = 14;

// Create an IRrecv object
IRrecv irrecv(IR_RECEIVE_PIN);

// Create a decode_results object
decode_results results;

const long interval = 1000;

unsigned long previousMillis = 0;

// Initialize the LCD object
LiquidCrystal_I2C lcd(0x27, 16, 2);

// Initialize the input number value
int count = 0;

// Initialize the random lucky point
int pointValue = 0;

// Initialize the upper and lower limit tips
int upper = 99;
int lower = 0;

void setup() {
  // Initialize the LCD screen
  lcd.init();
  lcd.backlight();

  // Start the serial communication
  Serial.begin(9600);

  // Enable the IR receiver
  irrecv.enableIRIn();

  // Initialize a new lucky point value
  initNewValue();
}

void loop() {
  // If a signal is received from the IR receiver
  if (irrecv.decode(&results)) {
    bool result = 0;
    String num = decodeKeyValue(results.value);

    // If the POWER button is pressed
    if (num == "POWER") {
      initNewValue(); // Initialize a new lucky point value
    }

    // If the CYCLE button is pressed
    else if (num == "CYCLE") {
      result = detectPoint(); // Detect the input number
      lcdShowInput(result); // Show the result on the LCD screen
    }

    // If a number button (0-9) is pressed, 
    //add the digit to the input number 
    //and detect the number if it is greater than or equal to 10
    else if (num >= "0" && num <= "9") {
      count = count * 10;
      count += num.toInt();
      if (count >= 10) {
        result = detectPoint();
      }
      lcdShowInput(result);
    }
    irrecv.resume();
  }
}

// Function to initialize a new lucky point value
void initNewValue() {
  // Set the random seed based on the analog value from pin A0
  randomSeed(analogRead(A0));

  // Generate a new random lucky point value
  pointValue = random(99);

  // Reset the upper and lower limit tips
  upper = 99;
  lower = 0;

  // Show the welcome message on the LCD screen
  lcd.clear();
  lcd.print("    Welcome!");
  lcd.setCursor(0, 1);
  lcd.print("Press Any Number");

  // Reset the input number value
  count = 0;

  // Print the lucky point value to the serial monitor
  Serial.print("point is ");
  Serial.println(pointValue);
}

// Detect the input number 
//and update the upper/lower limit tips accordingly
bool detectPoint() {
  if (count > pointValue) {
    if (count < upper)upper = count;
  }
  else if (count < pointValue) {
    if (count > lower)lower = count;
  }

  // If the input number is equal to the lucky point value, 
  else if (count == pointValue) {

    // Reset the input number and return true
    count = 0;
    return 1;
  }
  // Reset the input number and return false
  count = 0;
  return 0;
}

// Show the input number and the upper/lower limit tips
void lcdShowInput(bool result) {
  lcd.clear();

  // If the input number is equal to the lucky point value
  if (result == 1)
  {
    // Show the success message and initialize a new lucky point value
    lcd.setCursor(0, 1);
    lcd.print(" You've got it! ");
    delay(5000);
    initNewValue();
    return;
  }
  lcd.print("Enter number:");
  lcd.print(count);
  lcd.setCursor(0, 1);
  lcd.print(lower);
  lcd.print(" < Point < ");
  lcd.print(upper);
}

// Function to decode the key value from the IR receiver signal
String decodeKeyValue(long result)
{
  switch(result){
    case 0xFF6897:
      return "0";
    case 0xFF30CF:
      return "1"; 
    case 0xFF18E7:
      return "2"; 
    case 0xFF7A85:
      return "3"; 
    case 0xFF10EF:
      return "4"; 
    case 0xFF38C7:
      return "5"; 
    case 0xFF5AA5:
     return "6"; 
    case 0xFF42BD:
      return "7"; 
    case 0xFF4AB5:
      return "8"; 
    case 0xFF52AD:
      return "9"; 
    case 0xFF906F:
      return "+"; 
    case 0xFFA857:
      return "-"; 
    case 0xFFE01F:
      return "EQ"; 
    case 0xFFB04F:
      return "U/SD";
    case 0xFF9867:
      return "CYCLE";         
    case 0xFF22DD:
      return "PLAY/PAUSE";   
    case 0xFF02FD:
      return "BACKWARD";   
    case 0xFFC23D:
      return "FORWARD";   
    case 0xFFA25D:
      return "POWER";   
    case 0xFFE21D:
      return "MUTE";   
    case 0xFF629D:
      return "MODE";       
    case 0xFFFFFFFF:
      return "ERROR";   
    default :
      return "ERROR";
    }
}