Regarder sur YouTube

Tutoriel ESP32 36/55 - Jeu de devinette de nombres | Kit d'apprentissage IoT ESP32 de SunFounder

Dans ce tutoriel, nous allons créer un jeu amusant de devinette de nombres en utilisant le microcontrôleur ESP32 avec une télécommande infrarouge et un écran LCD. Le joueur tentera de deviner un nombre généré au hasard entre 0 et 99, le jeu fournissant des indices sur le fait que la devinette est trop élevée ou trop basse. Grâce à ce projet, vous apprendrez à utiliser le récepteur infrarouge, à afficher des valeurs sur un écran LCD et à gérer les entrées utilisateur à partir d'une télécommande. Vous pouvez vous référer à la vidéo pour plus de clarté (dans la vidéo à 00:00).

Matériel expliqué

Les principaux composants utilisés dans ce projet incluent le microcontrôleur ESP32, une télécommande infrarouge, un récepteur infrarouge et un écran LCD. L'ESP32 sert d'unité de traitement principale et est capable de gérer la communication sans fil, ce qui en fait un choix polyvalent pour les projets IoT. La télécommande infrarouge permet aux utilisateurs de faire des suppositions sans nécessiter d'interaction physique avec la carte, tandis que l'écran LCD affiche le statut du jeu et les messages.

Le récepteur infrarouge détecte les signaux de la télécommande et les décode pour une utilisation dans le jeu. Chaque pression sur un bouton de la télécommande correspond à une valeur spécifique que l'ESP32 peut interpréter. L'écran LCD fournit une interface visuelle pour l'utilisateur, affichant la plage de suppositions actuelle et si la supposition était correcte.

Détails de la fiche technique

• Assurez-vous que tous les composants sont évalués pour 3,3 V et 5 V lorsque cela est applicable.
• Utilisez des résistances de tirage appropriées pour le récepteur IR afin d'éviter les entrées flottantes.
• Envisagez d'utiliser un dissipateur thermique si vous fonctionnez à courant de sortie maximal pendant de longues périodes.
• Lors de l'utilisation du PWM, maintenez une fréquence d'environ 1 kHz pour des performances optimales.
• Soyez prudent avec le câblage ; assurez-vous que les connexions sont sécurisées pour éviter les pannes intermittentes.

Instructions de câblage

Pour configurer le câblage du jeu de devinette de nombres, commencez par connecter le récepteur infrarouge. Connectez le fil rouge de la broche droite du récepteur à l'alimentation de 3,3 V sur l'ESP32. Le fil noir doit aller à la masse, tandis que la broche gauche du récepteur infrarouge se connecte à la broche.14sur l'ESP32.

Ensuite, câblez l'afficheur LCD. Connectez la broche VCC de l_LCD à l'alimentation de 5 V sur l'ESP32 et la broche de masse à la terre. Les broches SDA et SCL de l_LCD doivent être connectées aux broches21et22respectivement. Assurez-vous qu'il y a deux espaces vides entre les connexions SDA et SCL pour éviter les conflits de broches. Enfin, assurez-vous de retirer tous les couvercles en plastique de la batterie avant d'alimenter la carte.

Exemples de code et guide étape par étape

Les extraits de code suivants illustrent les parties essentielles du programme utilisé pour le jeu de devinette de nombres. Nous commençons par inclure les bibliothèques nécessaires et à définir les identifiants clés.

#include 
#include 
#include 
#include 

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

Dans cet extrait, nous incluons des bibliothèques pour gérer la fonctionnalité de l'écran LCD et du récepteur IR. La broche pour le récepteur infrarouge est définie comme14, et nous créons des instances des objets nécessaires pour gérer l'entrée et la sortie.

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

Ce extrait montre la fonction de configuration où nous initialisons l'écran LCD, démarrons la communication série et activons le récepteur IR. La fonctioninitNewValue()est appelé à générer un nouveau nombre aléatoire que le joueur doit deviner.

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

Cette fonction vérifie la supposition du joueur par rapport au nombre généré aléatoirement, ajustant les limites supérieures et inférieures en conséquence. Si la supposition est correcte, elle réinitialise le compteur et retourne vrai.

Le code complet est chargé ci-dessous l'article pour votre référence.

Démonstration / À quoi s'attendre

Une fois que tout est câblé et que le code est téléchargé, le jeu vous indiquera d'appuyer sur n'importe quel numéro de la télécommande. Le jeu fournira ensuite des retours sur vos réponses, mettant à jour la plage des numéros possibles jusqu'à ce que vous deviniez correctement le numéro cible. Si vous appuyez sur le bouton POWER, le jeu se réinitialise et recommence (dans la vidéo à 02:30).

Les pièges courants incluent s'assurer que le récepteur infrarouge est correctement orienté et que toutes les connexions sont sécurisées. Si le jeu ne répond pas, vérifiez l'alimentation et assurez-vous que la bonne carte et le bon port sont sélectionnés dans l'IDE Arduino.

Horodatages vidéo

• 00:00 Début
• 2:17 Introduction au projet de jeu
• 4:37 Câblage
• 6:15 Code Arduino expliqué
• 12:32 Sélectionner la carte ESP32 et le port COM dans l'IDE Arduino
• 16:16 Jouer au jeu de deviner le nombre

Images

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>

 // Définir la broche du récepteur IR
const uint16_t IR_RECEIVE_PIN = 14;

 // Créer un objet IRrecv
IRrecv irrecv(IR_RECEIVE_PIN);

 // Créer un objet decode_results
decode_results results;

const long interval = 1000;

unsigned long previousMillis = 0;

 // Initialisez l'objet LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);

 // Initialiser la valeur du nombre d'entrée
int count = 0;

 // Initialiser le point chanceux aléatoire
int pointValue = 0;

 // Initialisez les conseils des limites supérieures et inférieures.
int upper = 99;
int lower = 0;

void setup() {
 // Initialiser l'écran LCD
  lcd.init();
  lcd.backlight();

 // Démarrez la communication série.
  Serial.begin(9600);

 // Activez le récepteur IR
  irrecv.enableIRIn();

 // Initialisez une nouvelle valeur de point chanceux
  initNewValue();
}

void loop() {
 // Si un signal est reçu du récepteur IR
  if (irrecv.decode(&results)) {
    bool result = 0;
    String num = decodeKeyValue(results.value);

 // Si le bouton POWER est enfoncé
    if (num == "POWER") {
      initNewValue(); // Initialisez une nouvelle valeur de point chanceux
    }

 // Si le bouton CYCLE est enfoncé
    else if (num == "CYCLE") {
      result = detectPoint(); // Détecter le nombre d'entrée
      lcdShowInput(result); // Affichez le résultat sur l'écran LCD.
    }

 // Si un bouton numérique (0-9) est pressé,
 // ajoutez le chiffre au nombre d'entrée
 // et détecter le nombre s'il est supérieur ou égal à 10
    else if (num >= "0" && num <= "9") {
      count = count * 10;
      count += num.toInt();
      if (count >= 10) {
        result = detectPoint();
      }
      lcdShowInput(result);
    }
    irrecv.resume();
  }
}

 // Fonction pour initialiser une nouvelle valeur de point chanceux
void initNewValue() {
 // Définissez la graine aléatoire en fonction de la valeur analogique du pin A0.
  randomSeed(analogRead(A0));

 // Générez une nouvelle valeur de point chanceux aléatoire.
  pointValue = random(99);

 // Réinitialisez les conseils des limites supérieures et inférieures.
  upper = 99;
  lower = 0;

 // Affichez le message de bienvenue sur l'écran LCD.
  lcd.clear();
  lcd.print("    Welcome!");
  lcd.setCursor(0, 1);
  lcd.print("Press Any Number");

 // Réinitialiser la valeur numérique d'entrée
  count = 0;

 // Imprimez la valeur du point chanceux sur le moniteur série.
  Serial.print("point is ");
  Serial.println(pointValue);
}

 // Détecter le nombre d'entrée
 // et mettre à jour les conseils de limite supérieure/inférieure en conséquence
bool detectPoint() {
  if (count > pointValue) {
    if (count < upper)upper = count;
  }
  else if (count < pointValue) {
    if (count > lower)lower = count;
  }

 // Si le nombre d'entrée est égal à la valeur du point chance,
  else if (count == pointValue) {

 // Réinitialisez le nombre d'entrée et renvoyez vrai.
    count = 0;
    return 1;
  }
 // Réinitialisez le nombre d'entrée et renvoyez faux.
  count = 0;
  return 0;
}

 // Afficher le numéro d'entrée et les conseils sur les limites supérieures/inferieures
void lcdShowInput(bool result) {
  lcd.clear();

 // Si le nombre d'entrée est égal à la valeur du point chanceux
  if (result == 1)
  {
 // Afficher le message de succès et initialiser une nouvelle valeur de point chanceux.
    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);
}

 // Fonction pour décoder la valeur de la clé à partir du signal du récepteur IR.
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";
    }
}