Guarda su YouTube

Tutorial ESP32 36/55 - Gioco di Indovinare il Numero | Kit di Apprendimento ESP32 IoT di SunFounder

In questo tutorial, creeremo un divertente gioco di indovinare il numero utilizzando il microcontrollore ESP32 insieme a un telecomando a infrarossi e a un display LCD. Il giocatore tenterà di indovinare un numero generato casualmente compreso tra 0 e 99, con il gioco che fornisce indizi su se l'indovinato è troppo alto o troppo basso. Attraverso questo progetto, imparerai a utilizzare il ricevitore a infrarossi, visualizzare valori su un LCD e gestire l'input dell'utente da un telecomando. Puoi fare riferimento al video per ulteriori chiarimenti (nel video a 00:00).

Hardware Spiegato

I componenti principali utilizzati in questo progetto includono il microcontroller ESP32, un telecomando a infrarossi, un ricevitore a infrarossi e un display LCD. L'ESP32 funge da unità di elaborazione principale ed è in grado di gestire la comunicazione wireless, rendendolo una scelta versatile per progetti IoT. Il telecomando a infrarossi consente agli utenti di inserire le proprie ipotesi senza richiedere interazione fisica con la scheda, mentre il display LCD mostra lo stato del gioco e le istruzioni.

Il ricevitore a infrarossi rileva i segnali dal telecomando e li decodifica per l'uso nel gioco. Ogni pressione di un pulsante sul telecomando corrisponde a un valore specifico che l'ESP32 può interpretare. Il display LCD fornisce un'interfaccia visiva per l'utente, mostrando l'attuale intervallo di stima e se la stima era corretta.

Dettagli della scheda tecnica

• Assicurati che tutti i componenti siano valutati per 3,3 V e 5 V dove applicabile.
• Utilizzare corretti resistori di pull-up per il ricevitore IR per evitare ingressi flottanti.
• Considera di utilizzare un dissipatore di calore se funzionando al massimo della corrente di uscita per periodi prolungati.
• Quando si utilizza il PWM, mantenere una frequenza di circa 1 kHz per prestazioni ottimali.
• Fai attenzione con il cablaggio; assicurati che le connessioni siano sicure per evitare guasti intermittenti.

Istruzioni di cablaggio

Per configurare il cablaggio per il gioco di indovinare il numero, inizia collegando il ricevitore a infrarossi. Collega il filo rosso dal pin destro del ricevitore all'alimentazione a 3,3 V sull'ESP32. Il filo nero dovrebbe andare a terra, mentre il pin sinistro del ricevitore a infrarossi si collega al pin.14sull'ESP32.

Successivamente, collega il display LCD. Collega il pin VCC del LCD all'alimentazione da 5 V dell'ESP32 e il pin di massa a terra. I pin SDA e SCL del LCD devono essere collegati ai pin21e22rispettivamente. Assicurati che ci siano due spazi vuoti tra le connessioni SDA e SCL per evitare conflitti sui pin. Infine, assicurati di rimuovere eventuali coperture di plastica dalla batteria prima di alimentare la scheda.

Esempi di codice e guida step-by-step

I seguenti frammenti di codice illustrano parti essenziali del programma utilizzato per il gioco del numero da indovinare. Iniziamo includendo le librerie necessarie e definendo gli identificatori chiave.

#include 
#include 
#include 
#include 

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

In questo estratto, includiamo librerie per gestire la funzionalità del LCD e del ricevitore IR. Il pin per il ricevitore infrarosso è definito come14, e creiamo istanze degli oggetti necessari per gestire l'input e l'output.

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

Questo frammento mostra la funzione di setup in cui inizializziamo il LCD, avviamo la comunicazione seriale e abilitiamo il ricevitore IR. La funzioneinitNewValue()è chiamato a generare un nuovo numero casuale che il giocatore deve indovinare.

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;
}

Questa funzione verifica il tentativo del giocatore rispetto al numero generato casualmente, regolando di conseguenza i limiti superiori e inferiori. Se il tentativo è corretto, ripristina il conteggio e restituisce vero.

Il codice completo è caricato sotto l'articolo per il tuo riferimento.

Dimostrazione / Cosa Aspettarsi

Una volta che tutto è cablato e il codice è caricato, il gioco ti inviterà a premere un numero qualsiasi sul telecomando. Il gioco poi fornirà un feedback sulle tue ipotesi, aggiornando l'intervallo dei numeri possibili fino a quando non indovini correttamente il numero target. Se premi il pulsante POWER, il gioco si resetta e ricomincia (nel video a 02:30).

Le trappole comuni includono assicurarsi che il ricevitore a infrarossi sia correttamente orientato e che tutte le connessioni siano sicure. Se il gioco non risponde, controlla l'alimentazione e verifica che la scheda e la porta corrette siano selezionate nell'IDE di Arduino.

Timestamp video

• 00:00 Inizio
• 2:17 Introduzione al progetto di gioco
• 4:37 Cablaggio
• 6:15 Codice Arduino spiegato
• 12:32 Selezione della scheda ESP32 e della porta COM nell'IDE Arduino
• 16:16 Giocando al gioco del numero da indovinare

Immagini

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";
    }
}