Vier gewinnt auf dem U 64 LED Matrix Panel - AZ-Delivery

Pendant ce temps, un vif échange d'informations par courrier électronique à nos clients a M. Sexton, qui nous devons le sablier électronique développé. Cela a blessé beaucoup de temps pour la programmation de son microcontrôleur et cette fois il « gagne quatre » Je joue le jeu pour deux joueurs sur le U 64 panneau matrice LED CJMCU 8 * 8 Moduleenvoyé avec RGBLEDs. Pour l'ensemble expérimental, j'avais toutes les parties à la maison. Alors, essayez.

4 victoires

Matériel utilisé

1

Nano V3.0 avec puce FT232RL et ATmega328

Ou alors: Nano V3.0 avec Atmega328 CH340

Alternative: Avec ATMEGA 328P Microcontrôleur

1

U 64 panneau matrice LED CJMCU 8 * 8 Module 

Montage d'essai (breadboard), 3 bouton et Câble (fil Jumper)


Matériel

Pour l'ensemble fini illustré, vous aurez encore besoin :

1

Logement

1

Batterie

1

LM2596S adaptateur d'alimentation DC-DC étape module vers le bas


Voici le schéma de câblage :

schéma

Comme souvent, les programmeurs de la société new-yorkaise Adafruit ont pris la peine de nous soulager, nous utilisateurs, de la partie la plus difficile de la programmation liée au matériel et ont développé une bibliothèque pour l'affichage LED et l'ont rendue disponible sur github ou via le gestionnaire de bibliothèque. C'est pourquoi il est inclus au début de l'esquisse avec
#include <Adafruit_NeoPixel.h>. Si ce n'est pas déjà fait, veuillez entrer NeoPixel dans la fenêtre de recherche du gestionnaire de bibliothèque (déjà installé pour moi).

gestionnaire de bibliothèque

Comme c'est souvent le cas, NeoPixel est une bibliothèque pour un grand nombre d'écrans RGBLED qui ont un point commun malgré leurs conceptions très différentes : Outre l'alimentation, il existe une seule ligne de données qui contrôle les RGBLED en série. Avec les lignes

 int numéro = 64;
 Adafruit_NeoPixel déshabiller(numéro, 6, NEO_GRB + NEO_KHZ800);

Nous instancions donc notre module 8x8 avec les lignes.

Huit colonnes et sept rangées sont disponibles pour le terrain de jeu, car la rangée supérieure est toujours nécessaire pour positionner la "pièce de jeu" suivante. Red commence. La LED supérieure gauche s'allume en rouge et peut être déplacée en conséquence avec les deux boutons pour la gauche (sur GPIO9) et la droite (sur GPIO10). Le déplacement est terminé avec le bouton du milieu (à GPIO8). Le point lumineux se déplace vers le bas jusqu'à ce que des champs libres deviennent disponibles. 

Après la routine de vérification pour savoir si un joueur a déjà atteint quatre cases de la même couleur horizontalement, verticalement ou en diagonale, une LED verte apparaît en haut à gauche et le deuxième joueur effectue son déplacement de la même manière. Ensuite, nous voyons une autre LED rouge en haut à gauche et ainsi de suite.

Si la routine de test aboutit à un résultat positif, les quatre LED RVB clignotent d'abord en série, puis l'ensemble de l'écran clignote dans les couleurs du gagnant. Le micro-contrôleur est alors prêt pour le prochain tour. Pour mettre fin prématurément à la partie, appuyez simultanément sur les deux touches de direction.

Voici l'esquisse dans son intégralité et en téléchargement :

 #include 
 int numéro = 64;
 Adafruit_NeoPixel déshabiller(numéro, 6, NEO_GRB + NEO_KHZ800);
 
 longue rouge = déshabiller.Couleur(5, 0, 0); longue vert = déshabiller.Couleur(0, 5, 0); longue Couleur = 0;
 octet zw1 = 0; int ZW2 = 0; // utilisé dans « champ de sortie »
 octet ZW3 = 0; // utilisé pour abaisser les pièces de jeu
 octet ZW4 = 0; // commencer les tests sur le terrain
 octet zw5 = 0; // champs de test de boucle interne Zaelwert 4
 octet ZW6 = 0; // Zaelwert boucle du milieu, tester une colonne
 octet ZW7 = 0; // Zaelwert boucle extérieure qui teste toutes les colonnes
 octet zw8 = 0; // pierres Déchus
 octet zw9 = 0; // gagnant de sortie couleur
 octet zw10 = 0; // affichage Supprimer et sur le terrain
 octet ZW11 = 0; // clignotant pierres vainqueur
 longue farbe_1 = 0; longue farbe_2 = 0; // Vainqueur Couleur
 octet position 1 = 0; octet position_2 = 0; octet position_3 = 0; octet position_4 = 0; // Position pierres vainqueur
 
 // 0 -> Non utilisé; 1 -> rouge; 2 -> vert
 octet champcorrespondant [64] = {
   1, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0
 };
 
 octet droite = 10; octet La gauche = 9; octet vers le bas = 8; // nombre de ports de quantité nécessaire
 
 octet direction = 0 ; // 1 -> droite; 2 -> gauche; 3 -> vers le bas
 octet status_start = 1; // 1 -> rouge; 2 -> vert
 octet status_spiel = 1 ; // 1 -> rouge; 2 -> vert
 octet position_0 = 0; // pointeur pour le champ
 octet test_rot = 0; octet test_gruen = 0; octet gagnant = 0; // Nécessite pour déterminer le gagnant
 
 annuler installer() {
 
   En série.commencer(9600);
 
   déshabiller.commencer();
   déshabiller.spectacle(); // Initialiser tous les pixels à « off »
 
   pinMode(droite, SAISIR); digitalWrite (droite, HAUTE);
   pinMode(La gauche, SAISIR); digitalWrite (La gauche, HAUTE);
   pinMode(vers le bas, SAISIR); digitalWrite (vers le bas, HAUTE);
 
   ausgabe_spielfeld ();
 }
 
 annuler boucle() {
 
   // clavier de requête et saut dans le programme correspondant
   faire {
     
     si (lecture numérique(droite) == FAIBLE && lecture numérique(La gauche) == FAIBLE) {
       zw8 = 56;
       test_spielende ();
    };
     si ( lecture numérique(droite) == FAIBLE) {
       direction = 1; rechts_0 ();
    }
     si ( lecture numérique(La gauche) == FAIBLE) {
       direction = 2; links_0 ();
    }
     si ( lecture numérique(vers le bas) == FAIBLE) {
       si (champcorrespondant [position_0 + 8] == 0) {
         direction = 3;
         runter_0 (); zw8 ++; // Nombre Durchlaeufe + 1
         test_spielende ();
      };
    }
  }
   tandis que ( direction == 0);
   direction = 0; // direction Loesch Ender
 
 
   ausgabe_spielfeld ();
   retard(300);
 }
 
 // ------------- tester s'il y a un gagnant ------------------
 // ---------- programme est appelé après l'abaissement d'une pierre
 annuler test_spielende () {
 
   // ----------- ------------ test ci-dessus en diagonale
   // ---------- ---------- 3 verschaltelte cycles
 
   ZW4 = 32; // commencer les tests sur le terrain
   gagnant = 0; ZW7 = 0;
 
   faire {
     ZW6 = 0;
 
     faire {
       zw5 = 0; // Zaelschleife
       test_rot = 0; test_gruen = 0;
 
       // Test de 4 cellules diegonal ci-dessus
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
        };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
        };
 
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
          };
           si (zw5 == 1) {
             position_2 = ZW4;
          };
           si (zw5 == 2) {
             position_3 = ZW4;
          };
           si (zw5 == 3) {
             position_4 = ZW4;
          };
        };
 
         ZW4 = ZW4 - 7; zw5++;
      }
       tandis que (zw5 != 4);
 
       si (test_rot == 4) {
         gagnant = 1;
      } autre {
         test_rot = 0;
      };
       si (test_gruen == 4) {
         gagnant = 2;
      } autre {
         test_gruen = 0;
      };
       ZW4 = ZW4 + 36; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
      };
    }
     tandis que ( ZW6 != 4);
 
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 5;
    };
  }
   tandis que (ZW7 != 5);
 
   // ----------- ----------- test diagonale vers le bas
   // ---------- ---------- 3 cycles imbriqués
 
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
 
   faire {
     ZW6 = 0;
 
     faire {
       zw5 = 0; // boucle de comptage
       test_rot = 0; test_gruen = 0;
 
       // cellules de test 4 en diagonale vers le bas
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
        };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
        };
 
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
          };
           si (zw5 == 1) {
             position_2 = ZW4;
          };
           si (zw5 == 2) {
             position_3 = ZW4;
          };
           si (zw5 == 3) {
             position_4 = ZW4;
          };
        };
 
         ZW4 = ZW4 + 9; zw5++;
      }
       tandis que (zw5 != 4);
 
       si (test_rot == 4) {
         gagnant = 1;
      } autre {
         test_rot = 0;
      };
       si (test_gruen == 4) {
         gagnant = 2;
      } autre {
         test_gruen = 0;
      };
       ZW4 = ZW4 - 28; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
      };
    }
     tandis que ( ZW6 != 4);
 
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 5;
    };
  }
   tandis que (ZW7 != 5);
 
   // ------------ perpendiculaire test ---------------
   // ---------- ---------- 3 verschaltelte cycles
 
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
   faire {
     ZW6 = 0;
 
     faire {
       zw5 = 0; // zaelschleife
       test_rot = 0; test_gruen = 0;
 
       // tester 4 cellules perpendiculaires
       faire {
         si ( champcorrespondant [ZW4] == 1) {
           test_rot ++;
        };
         si ( champcorrespondant [ZW4] == 2) {
           test_gruen ++;
        };
 
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (zw5 == 0) {
             position 1 = ZW4;
          };
           si (zw5 == 1) {
             position_2 = ZW4;
          };
           si (zw5 == 2) {
             position_3 = ZW4;
          };
           si (zw5 == 3) {
             position_4 = ZW4;
          };
        };
 
         ZW4 = ZW4 + 8; zw5++;
      }
       tandis que (zw5 != 4);
 
       si (test_rot == 4) {
         gagnant = 1;
      } autre {
         test_rot = 0;
      };
       si (test_gruen == 4) {
         gagnant = 2;
      } autre {
         test_gruen = 0;
      };
       ZW4 = ZW4 - 24; ZW6++;
       si (gagnant != 0) {
         ZW6 = 4;
      };
    }
     tandis que ( ZW6 != 4);
 
     ZW4 = ZW4 - 31; ZW7++;
     si (gagnant != 0) {
       ZW7 = 8;
    };
  }
   tandis que (ZW7 != 8);
 
   // ------------- -------------- Niveau d'essai
   // ---------- ---------- 3 cycles imbriqués
   ZW4 = 8; // commencer les tests sur le terrain
   ZW7 = 0;
   faire {
     ZW6 = 0;
 
     faire {
       zw5 = 0;
       test_rot = 0; test_gruen = 0;
 
       // test 4 cellules horizontalement
       faire {
         si ( champcorrespondant [zw4] == 1) {
           test_rot ++;
        };
         si ( champcorrespondant [zw4] == 2) {
           test_gruen ++;
        };
 
         // Notez la position de la victoire
         si (gagnant == 0) {
           si (ZW5 == 0) {
             position 1 = zw4;
          };
           si (ZW5 == 1) {
             Position_2 = zw4;
          };
           si (ZW5 == 2) {
             Position_3 = zw4;
          };
           si (ZW5 == 3) {
             Position_4 = zw4;
          };
        };
 
         zw4++; ZW5++;
      }
       tandis que (ZW5 != 4);
 
       si (test_rot == 4) {
         gagnant = 1;
      } autre {
         test_rot = 0;
      };
       si (test_gruen == 4) {
         gagnant = 2;
      } autre {
         test_gruen = 0;
      };
       zw4 = zw4 + 4; zw6++;
       si (gagnant != 0) {
         zw6 = 7;
      };
    }
     tandis que ( zw6 != 7);
 
     zw4 = zw4 - 55; zw7++;
     si (gagnant != 0) {
       zw7 = 5;
    };
  }
   tandis que (zw7 != 5);
 
   // Couleurs gagnant
   si (gagnant == 1) {
     COLOR_1 = rouge;
     COLOR_2 = rouge;
     La fin (); // gagnant de sortie rouge
  };
   si (gagnant == 2) {
     COLOR_1 = vert;
     COLOR_2 = vert;
     La fin (); // gagnant de sortie Couleur Vert
  };
   si (zw8 == 56 ) {
     COLOR_1 = vert;
     COLOR_2 = rouge;
     La fin (); // affiche dessiner
  };
 
   position 1 = 0; Position_2 = 0; Position_3 = 0; Position_4 = 0;
   test_rot = 0; test_gruen = 0;
 }
 
 // ---------- ---------- couleur gagnants édition
 
 annuler La fin () {
   SW11 = 0;
 
   si (zw8 != 56 ) {
     faire {
       déshabiller.setPixelColor ( position 1, 0, 0, 0);
       déshabiller.setPixelColor ( Position_2, 0, 0, 0);
       déshabiller.setPixelColor ( Position_3, 0, 0, 0);
       déshabiller.setPixelColor ( Position_4, 0, 0, 0);
       déshabiller.spectacle(); retard(200);
       déshabiller.setPixelColor ( position 1, COLOR_1);
       déshabiller.setPixelColor ( Position_2, COLOR_1);
       déshabiller.setPixelColor ( Position_3, COLOR_1);
       déshabiller.setPixelColor ( Position_4, COLOR_1);
       déshabiller.spectacle(); retard(200);
       SW11++;
    }
     tandis que ( SW11 != 5);
  }
 
   zwart = 0;
   faire {
     déshabiller.setPixelColor ( zwart, COLOR_1); zwart++;
     déshabiller.setPixelColor ( zwart, COLOR_2); zwart++;
  }
   tandis que (zwart != 64);
   déshabiller.spectacle();
 
   retard(2000);
 
   // ---------- ----------- préparation nouveau départ
 
   ZW10 = 0;
   faire {
     déshabiller.setPixelColor ( ZW10, 0, 0, 0); champcorrespondant [ZW10] = 0;
     ZW10++;
  }
   tandis que ( ZW10 != 64);
   déshabiller.spectacle();
 
   champcorrespondant [0] = 1; ausgabe_spielfeld ();
   zw1 = 0; ZW2 = 0; ZW3 = 0; zw4 = 0; ZW5 = 0; zw6 = 0; zw7 = 0; zw8 = 0; zwart = 0; ZW10 = 0;
   position 1 = 0; Position_2 = 0; Position_3 = 0; Position_4 = 0;
   position_0 = 0;
 
   // changement Démarrer couleur jeu
   COLOR_1 = 0; COLOR_2 = 0; gagnant = 0;  
 
   si (status_start == 1) {
     Couleur = vert; status_spiel = 2;status_start=2;
     champcorrespondant [0] = 2;
  } autre {
     Couleur = rouge;
     champcorrespondant [0] = 1; status_spiel = 1;status_start=1;
  };
   
   ausgabe_spielfeld ();
 }
 
 // ---------- ---------- Un pas à gauche
 annuler links_0 () {
   si (position_0 != 0) {
     champcorrespondant [position_0] = 0;
     position_0--;
     champcorrespondant [ position_0 ] = status_spiel;
  };
 }
 
 // ---------- ---------- Une étape vers la droite
 annuler rechts_0 () {
   si (position_0 != 7) {
     champcorrespondant [position_0] = 0;
     position_0++;
     champcorrespondant [ position_0 ] = status_spiel;
  };
 }
 
 // ---------- ---------- abaisser la pièce de jeu
 annuler runter_0 () {
   ZW3 = 0;
   faire {
     si (champcorrespondant [position_0 + 8] == 0 ) {
       champcorrespondant [position_0] = 0; position_0 = position_0 + 8; champcorrespondant [position_0] = status_spiel;
       ZW3++;
       ausgabe_spielfeld (); retard(200);
    }
     autre {
       ZW3 = 7;
    }
  }
   tandis que (ZW3 != 7) ;
   direction = 0; position_0 = 0;
   si (status_spiel == 1 ) {
     status_spiel = 2;
     champcorrespondant [position_0] = 2;
  } autre {
     status_spiel = 1;
     champcorrespondant [position_0] = 1;
  };
   ausgabe_spielfeld ();
 }
 
 // ---------- ---------- champ de sortie
 annuler ausgabe_spielfeld () {
   zw1 = 0;
 
   faire {
     ZW2 = champcorrespondant [zw1];
     si (ZW2 == 0) {
       déshabiller.setPixelColor ( zw1, 0, 0, 0);
    };
     si (ZW2 == 1) {
       déshabiller.setPixelColor ( zw1, rouge);
    };
     si (ZW2 == 2) {
       déshabiller.setPixelColor ( zw1, vert);
    };
     zw1++;
  }
   tandis que (zw1 != 64);
   déshabiller.spectacle();
 }
 
 // HUK Vier_gewinnt_4.4 27/07/2021

Vous pouvez également jouer à Four Wins sur la tablette murale AZ-Touch. Jörn Weise avait présenté cette option dans son blog le 3 juillet 2021.

Les deux versions présentées sont conçues pour deux joueurs et, outre le joli affichage, offrent la routine de vérification si un joueur a déjà gagné. Pour ceux qui veulent jouer contre un ordinateur avec un jeu fort, la version d'Al Sweigart sur le Raspberry Pi est recommandée. A ma grande honte, je dois admettre que je perds de temps en temps. Vous préférez donc jouer contre ma petite-fille avec le sketch de M. Küster sur le module U 64 LED Matrix Panel CJMCU-8 * 8 ?



Amusez-vous bien à reconstruire et à jouer.

DisplaysFür arduinoProjekte für anfänger

9 commentaires

Andreas Wolter

Andreas Wolter

@mircemk: you have to change the order in the array “byte spielfeld 64”. But it’s difficult to change that. The odd rows (if start with 1) should be the same and the even rows are mirrored. Sorry but you hav to search the parts by yourself step by step.

If you find a solution please tell us.

Best regards,
Andreas Wolter
AZ-Delivery Blog

mircemk

mircemk

Hello,
My matrix is slightly different from yours ie. the diodes light up one by one in a zig zag pattern, and with yours each new row starts on the left. What code modification do I need to do. Do you have an idea?
Thank you

Andreas Wolter

Andreas Wolter

@René: Wenn auch mit den Testsketches die LED nicht eingeschaltet wird, gehe ich davon aus, dass in dem Modul etwas nicht korrekt verlötet ist. SIe könnten versuchen, einen Testsketch so anzupassen, dass genau diese LED eingeschaltet wird. Wenn diese nicht leuchtet, müssen Sie den Support kontaktieren und das Modul austauschen lassen.

Grüße,
Andreas Wolter
AZ-Delivery Blog

René

René

Hi,
also auch mit einem Test-Sketch/Beispiel Sketch aus der Neopixel Bibliothek bleibt die erste LED dunkel. Keine Ahnung warum das so ist.
Wenn man das 4-Gewinnt Programm startet, dann ist es ja auch so, dass die erste LED dunkel ist und man eben direkt bei der zweiten startet. Also entweder ist das Modul defekt oder irgendein anderer Fehler ist vorhanden.
Habe beides, Board und Matrix bei euch bezogen.

Andreas Wolter

Andreas Wolter

@Renè: haben Sie am Programm änderungen vorgenommen?
Wenn nicht, empfehle ich, ein Testprogramm auf den MC zu laden, um zu sehen, ob die LEDs alle ordnungsgemäß angesprochen werden.

Unser Blogautor Bernd Albrecht hat den Sketch nochmal getestet und er funktioniert so wie er soll.
Ich denke aber, dass wir den Fehler finden werden.

Grüße,
Andreas Wolter
AZ-Delivery Blog

René

René

Ich habe jetzt einen Fehler im Programm:
Beim Start des Arduinos wird nicht das ganz oben, ganz links befindliche LED rot aktiviert sondert immer ganz oben und eins nach rechts.
Hab versucht das zu finden, aber kann es sein, dass die LED Matrix falsch initialisiert wird?

René

René

Super, vielen Dank.

Andreas Wolter

Andreas Wolter

Wir haben den Link zum Gehäuse ergänzt. Es ist kein 3D-Modell für den Drucker.

Außerdem hat uns Herr Küster ein Update zur Verfügung gestellt, das Sie jetzt ebenfalls im Beitrag finden.

Mit freundlichen Grüßen,
Andreas Wolter
AZ-Delivery Blog

René

René

Cooles Projekt, würde ich gern nachbauen aber den Hinweis zum Gehäuse finde ich sehr lustig ;)
Könntet ihr vielleicht erwähnen welches ihr dazu genutzt habt?
Oder noch besser wäre, wenn das eine stl für einen 3D-Druck wäre ;)

Laisser un commentaire

Tous les commentaires sont modérés avant d'être publiés

Articles de blog recommandés

  1. ESP32 jetzt über den Boardverwalter installieren - AZ-Delivery
  2. Internet-Radio mit dem ESP32 - UPDATE - AZ-Delivery
  3. Arduino IDE - Programmieren für Einsteiger - Teil 1 - AZ-Delivery
  4. ESP32 - das Multitalent - AZ-Delivery