Tutorial ESP32 36/55 - Joc de ghicit numărul | Kitul de învățare IoT ESP32 de la SunFounder

Tutorial ESP32 36/55 - Joc de ghicit numărul | Kitul de învățare IoT ESP32 de la SunFounder

În acest tutorial, vom crea un joc distractiv de ghicit numere folosind microcontrolerul ESP32 împreună cu o telecomandă în infraroșu și un afișaj LCD. Jucătorul va încerca să ghicească un număr generat aleatoriu între 0 și 99, jocul oferind indicii despre dacă ghicitul este prea mare sau prea mic. Prin acest proiect, vei învăța cum să folosești receptorul în infraroșu, să afișezi valori pe un LCD și să gestionezi intrarea utilizatorului de la o telecomandă. Poți consulta videoclipul pentru claritate suplimentară (în videoclip la 00:00).

Hardware Explicat

Componentele principale utilizate în acest proiect includ microcontrolerul ESP32, o telecomandă în infraroșu, un receptor în infraroșu și un afișaj LCD. ESP32 servește ca unitate principală de procesare și este capabil să gestioneze comunicarea wireless, fiind o alegere versatilă pentru proiecte IoT. Telecomanda în infraroșu permite utilizatorilor să introducă ghicituri fără a necesita interacțiune fizică cu placa, în timp ce LCD-ul afișează starea jocului și solicitările.

Receptorul în infraroșu detectează semnalele de la telecomandă și le decodifică pentru utilizare în joc. Fiecare apăsare de buton pe telecomandă corespunde unei valori specifice pe care ESP32 o poate interpreta. Afișajul LCD oferă o interfață vizuală pentru utilizator, arătând intervalul curent de ghicit și dacă ghicitul a fost corect.

Detalii din Fișa Tehnică

• Asigură-te că toate componentele sunt evaluate pentru 3,3 V și 5 V acolo unde este cazul.
• Folosește rezistențe pull-up adecvate pentru receptorul IR pentru a evita intrările flotante.
• Ia în considerare utilizarea unui radiator dacă rulezi la curent maxim de ieșire pentru perioade extinse.
• Când folosești PWM, menține o frecvență de aproximativ 1 kHz pentru performanță optimă.
• Fii atent la cablare; asigură-te că conexiunile sunt sigure pentru a evita defecțiuni intermitente.

Instrucțiuni de Cablare

Pentru a configura cablarea pentru jocul de ghicit numere, începe prin conectarea receptorului în infraroșu. Conectează firul roșu de la pinul drept al receptorului la sursa de alimentare de 3,3 V de pe ESP32. Firul negru ar trebui să meargă la masă, în timp ce pinul stâng al receptorului în infraroșu se conectează la pinul 14 de pe ESP32.

Apoi, conectează afișajul LCD. Conectează pinul VCC al LCD-ului la sursa de 5 V de pe ESP32 și pinul de masă la masă. Pinii SDA și SCL ai LCD-ului ar trebui conectați la pinii 21 și, respectiv, 22. Asigură-te că există două spații goale între conexiunile SDA și SCL pentru a evita conflictele de pini. În final, asigură-te că îndepărtezi orice capace din plastic de pe baterie înainte de a alimenta placa.

Exemple de Cod & Explicații

Fragmentele de cod următoare ilustrează părți esențiale ale programului utilizat pentru jocul de ghicit numere. Începem prin includerea bibliotecilor necesare și definirea identificatorilor cheie.

#include 
#include 
#include 
#include 

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

În acest extras, includem biblioteci pentru gestionarea funcționalității LCD-ului și a receptorului IR. Pinul pentru receptorul în infraroșu este definit ca 14, și creăm instanțe ale obiectelor necesare pentru a gestiona intrarea și ieșirea.

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

Acest fragment arată funcția de configurare unde inițializăm LCD-ul, începem comunicarea serială și activăm receptorul IR. Funcția initNewValue() este apelată pentru a genera un nou număr aleatoriu pe care jucătorul să îl ghicească.

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

Această funcție verifică ghicitul jucătorului față de numărul generat aleatoriu, ajustând limitele superioare și inferioare în consecință. Dacă ghicitul este corect, resetează contorul și returnează true.

Codul complet este încărcat mai jos în articol pentru referința ta.

Demonstrație / Ce să Te Aștepți

Odată ce totul este conectat și codul este încărcat, jocul te va solicita să apeși orice număr de pe telecomandă. Jocul îți va oferi apoi feedback cu privire la ghicirile tale, actualizând intervalul de numere posibile până când ghicești corect numărul țintă. Dacă apeși butonul POWER, jocul se resetează și începe din nou (în video la 02:30).

Capcanele frecvente includ asigurarea că receptorul infraroșu este orientat corect și că toate conexiunile sunt sigure. Dacă jocul nu răspunde, verifică sursa de alimentare și confirmă că placa și portul corecte sunt selectate în Arduino IDE.

Marcaje video

• 00:00 Start
• 2:17 Introducere în proiectul jocului
• 4:37 Conexiuni
• 6:15 Codul Arduino explicat
• 12:32 Selectarea plăcii ESP32 și a portului COM în Arduino IDE
• 16:16 Jucând jocul de ghicit numere

Imagini

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