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.
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 |
||
|
Montage d'essai (breadboard), 3 bouton et Câble (fil Jumper) |
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 :
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).
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 :
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.
