Échiquier électronique (prototype de démonstration 4x4)

Outils et machines nécessaires

Applications et services en ligne

Arduino IDE

À propos de ce projet

Salut les créateurs,

Je suis Tahir Miriyev, diplômé de 2018 de l'Université technique du Moyen-Orient, Ankara/Turquie. Je me suis spécialisé en mathématiques appliquées, mais j'ai toujours aimé faire des trucs, surtout quand cela impliquait du travail manuel avec l'électronique, la conception et la programmation. Grâce à un cours unique sur le prototypage, offert à notre département de design industriel, j'ai eu la chance de faire quelque chose de vraiment intéressant. Le projet peut être traité comme un projet à terme, d'une durée d'un semestre entier (4 mois). Les étudiants ont eu pour tâche de trouver une approche créative pour concevoir des produits/démonstrations déjà existants et de réaliser leurs idées à l'aide de microcontrôleurs et de capteurs Arduino. Je pensais aux échecs, et après avoir fait quelques recherches sur des projets réussis, j'ai remarqué que dans les projets précédents, les fabricants utilisaient essentiellement des moteurs d'échecs prêts à l'emploi (où tous les mouvements de chaque figure étaient programmés dans le noyau), avec Raspberry Pi, quelques MUX , LED et interrupteurs à lames. Dans mon projet, cependant, j'ai décidé de me débarrasser de tout logiciel externe en termes de moteur d'échecs et de trouver une solution créative au problème de reconnaissance de figures, en utilisant un lecteur RFID, des capteurs à effet Hall et Arduino Mega.

Pour faire simple, supposons que vous ayez un échiquier avec un "cerveau" =microcontrôleur, et que vous deviez faire comprendre à votre échiquier quelle figure vous teniez dans votre main et où vous l'avez placée. C'est le problème de la reconnaissance des figures. La solution à ce problème est triviale lorsque vous avez un moteur d'échecs avec toutes les pièces debout sur leurs positions initiales sur l'échiquier. Avant d'expliquer pourquoi il en est ainsi, permettez-moi de faire quelques remarques.

Pour ceux qui sont enthousiasmés par la façon dont les choses fonctionnent ici, je dois clarifier pourquoi nous avons besoin d'interrupteurs à lames (ou dans mon cas, j'ai utilisé des capteurs à effet Hall) :si vous placez un aimant sous chaque pièce et le ramassez d'un carré sur le tableau (en supposant qu'il y ait un interrupteur à lames sous chaque carré) en raison de l'existence / de la non-existence du champ magnétique au-dessus du capteur, vous pouvez faire comprendre à votre contrôleur s'il y a / n'y a pas une pièce debout sur le carré. Cependant, cela ne dit toujours rien au microcontrôleur sur la pièce exacte qui se trouve sur la place. Il indique seulement qu'il y a/pas un morceau sur un carré. À ce stade, nous sommes confrontés à un problème de reconnaissance de figures, qui peut être résolu à l'aide d'un moteur d'échecs, avec toutes les pièces placées sur leurs positions initiales lorsque le jeu d'échecs commence. De cette façon, le microcontrôleur « sait » où se trouve chaque pièce dès le début, avec toutes les adresses fixées dans la mémoire. Néanmoins, cela nous apporte une énorme limitation :vous ne pouvez pas sélectionner, disons, n'importe quel nombre de pièces et les placer au hasard n'importe où sur le plateau et commencer à analyser le jeu. Vous devez toujours recommencer depuis le début, toutes les pièces doivent être sur le plateau à l'origine, car c'est le seul moyen pour le microcontrôleur de suivre leur emplacement une fois que vous avez soulevé une pièce et placée sur un autre carré. Essentiellement, c'est le problème que j'ai remarqué et j'ai décidé de travailler dessus.

Ma solution était assez simple, bien que créative. J'ai placé un lecteur RFID sur la face avant d'un tableau. Pendant ce temps, j'ai attaché non seulement un aimant sous les pièces, mais aussi une étiquette RFID, chaque pièce ayant un identifiant unique. Par conséquent, avant de placer une figure sur n'importe quel carré de votre choix, vous pouvez d'abord tenir la pièce près du lecteur RFID et le laisser lire l'ID, identifier la pièce, l'enregistrer dans la mémoire, puis vous pouvez la placer où vous voulez. De plus, au lieu d'utiliser des commutateurs à lames, afin de simplifier la conception du circuit, j'ai utilisé des capteurs à effet Hall, qui fonctionnent de manière similaire, avec la seule différence d'envoyer 0 ou 1 à un microcontrôleur en tant que données numériques, ce qui signifie "il y a" ou "il n'y a pas" de pièce sur le carré, respectivement. J'ai également ajouté des LED (malheureusement pas de la même couleur, je n'en avais pas), de sorte que lorsque vous soulevez la pièce, tous les emplacements carrés, où une pièce soulevée pourrait être placée, s'allument. Considérez-le comme une pratique éducative pour les apprenants d'échecs :)

Enfin, je voudrais noter que malgré le fait que j'aie utilisé plusieurs techniques, le projet reste simple et compréhensible, pas trop élaboré ou trop compliqué. Je n'ai pas eu assez de temps pour procéder à l'échiquier 8x8 (aussi parce que 64 capteurs à effet Hall sont coûteux en Turquie, j'ai couvert toutes les dépenses liées au projet), c'est pourquoi j'ai fait la version démo 4x4 avec seulement deux pièces testées :Pion et Reine . Au lieu d'utiliser un moteur d'échecs, j'ai écrit un code source pour Arduino, qui génère tout.

Avant de passer au pas à pas explication de la façon dont le projet a été réalisé, je recommanderais de regarder une vidéo illustrative et d'avoir une idée intuitive de ce dont je parle.

Remarque 1 : une des LED rouges (première de la rangée/de gauche à droite) a grillé, peu importe.

Note #2 :Bien que largement utilisée, d'après mon expérience, je peux dire que la technologie RFID n'est pas la meilleure idée à utiliser dans les applications de bricolage (bien sûr si vous avez des alternatives). Avant que tout ne fonctionne, j'ai fait de nombreux essais en plaçant des pièces d'échecs près du lecteur et en attendant qu'il lise correctement l'ID. Le port série doit être configuré pour cela, car la façon dont le lecteur RFID lit l'ID n'est qu'un casse-tête. Il faut essayer par lui-même pour comprendre le problème.

Voici la liste de tous les outils J'ai utilisé pour le projet :

Composants électroniques :

• Planche à pain (x1)

• Capteurs à effet Hall omnidirectionnels A1126LUA-T (IC-1126 SW OMNI 3-SIP ALLEGRO) (x16)

• LED 5 mm de base (x16)

• Cavaliers

• Lecteur et antenne RFID 125 kHz (x1)

• Arduino Mega (x1)

• Balises RFID 3M (x2)

Autres matériaux :

• Plexiglas

• Papier glacé

• Planches courtes (en bois)

• Peinture acrylique (vert foncé et crème) x2

• Carton fin

• Aimants ronds 10 mm (x2)

• Pièces de pion et de reine

• Fer à souder et matériaux à souder

Il est temps d'expliquer comment les choses ont été faites. Veuillez suivre la description étape par étape :

1. Prenez un carton de 21x21 cm, ainsi que du carton supplémentaire pour découper et coller les parois de la partie supérieure du plateau, afin de faire 16 carrés avec A B C D 1 2 3 4 énumérés. Le carton étant fin, vous pouvez coller 16 capteurs à effet Hall dans chaque carré, avec 3 pieds chacun et 16 LED avec 2 pieds chacun.

2. Après avoir défini les composants, vous devrez effectuer des soudures, pour souder les pattes des capteurs à effet Hall et les LED aux câbles de connexion. À ce stade, je recommanderais de sélectionner les fils de couleur de manière intelligente, afin de ne pas vous tromper avec les pattes + et - des LED, ainsi que les pattes VCC, GND et PIN des capteurs à effet Hall. Bien sûr, on pourrait imprimer un PCB avec des capteurs et même des LED de type WS2812 déjà soudées, mais j'ai décidé de garder le projet simple et de faire un peu plus de "travail manuel". À ce stade, tout ce que vous avez à faire est de préparer les cordons et les capteurs, sur les étapes ultérieures suivant le schéma de Fritzing, vous pouvez voir où vous devez attacher l'extrémité de chaque fil. En bref, certains d'entre eux iront directement aux broches de l'Arduino Mega (il y en a assez sur l'Arduino), d'autres à la planche à pain et tous les GND peuvent être soudés à un seul morceau de cordon (ce qui fait un terrain d'entente) qui plus tard doit être connecté au GND de la carte Arduino. Une note importante ici :les capteurs à effet Hall sont OMNIDIRECTIONNELS, ce qui signifie que peu importe quel pôle d'un aimant sera maintenu près du capteur, il enverra 0 données lorsqu'il y a un champ magnétique à proximité et 1 lorsqu'il n'y en a pas, à savoir, l'aimant est éloigné (plus loin que disons 5 sm) du capteur.

3. Préparez un carton similaire de 21x21 cm et fixez-y l'Arduino Mega et une longue planche à pain. Vous pouvez également découper à nouveau 4 murs de n'importe quelle hauteur dans du carton et les coller verticalement avec ces deux couches de planches carrées de 21x21 cm. Suivez ensuite Fritzing Schematics pour mettre les choses en place. Vous pouvez également régler le lecteur RFID une fois que vous avez terminé avec les LED et les capteurs à effet Hall.

4. Testez si toutes les LED et tous les capteurs fonctionnent en envoyant des signaux à l'aide de codes de base. N'évitez pas cette étape car elle vous permettra de tester si tout fonctionne correctement et de passer à la construction ultérieure du tableau.

5. Préparez le pion et la reine, avec deux aimants d'un rayon de 10 cm attachés en dessous, ainsi que des étiquettes RFID rondes. Plus tard, vous devrez lire les identifiants de ces balises à partir de l'écran série sur l'IDE Arduino.

6. Si tout fonctionne bien, vous pouvez démarrer le code principal et essayer des choses !

7 (facultatif). Vous pouvez faire un travail artistique avec du bois qui donnera à votre démo une vue plus naturelle. Cela dépend de votre volonté et de votre imagination.

Voici quelques vidéos et photos de différentes étapes :

Merci pour votre attention! Testez tout et soyez libre d'écrire dans les commentaires sur tout type d'erreurs que j'ai manqué, des améliorations, des suggestions, etc. .com) ou ajouter sur Skype (tahir.miriyev9r1), afin que nous puissions planifier une conversation et discuter des choses en détail. Bonne chance !

Code

• thinK_code.ino

thinK_code.inoArduino

#include SoftwareSerial RFID (11, 12);//----------------------------------------------- ------------ DÉBUT ------------------------------------- -------------------------------------------------- ------int empty_pos[2];int figure_pos[2][2]; //penser à une position de figure comme une matrice de deux vecteurs (reine et pion) avec trois entrées (x pos, y pos et valeur 1(reine), 2(pawn)int new_id[14] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};int id_type_matrix[4][4] ={{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};int temp =0;int queen_id[14] ={2, 53, 65, 48, 48, 56, 51, 49, 55, 70, 65, 51, 52, 3};int pawn_id[14] ={2, 53, 65, 48, 48, 56, 51, 56, 67, 49, 56, 52, 68, 3};int temp_vect[2];int count =0;int ID =0;int yeni_id[14]; // matrice de matrice initiale pour capteurs à effet hallint hes_bool_matrix[4][4];// liste des effets Hall broches des capteurs sur Arduinoconst int hes_00 =44;const int hes_01 =45;const int hes_02 =46;const int hes_03 =47;const int hes_10 =48;const int hes_11 =49;const int hes_12 =50;const int hes_13 =2;const int hes_20 =3;const int hes_21 =4;const int hes_22 =5;const int hes_23 =6;const int hes_30 =7;const int hes_31 =8;const int hes_32 =9;const int hes_33 =10;int hes_pin_matrix[4][4] ={ {hes_00, il s_01, hes_02, hes_03}, {hes_10, hes_11, hes_12, hes_13}, {hes_20, hes_21, hes_22, hes_23}, {hes_30, hes_31, hes_32, hes_33}} ;//LED pinsconst led int int led_00 =22 =23;const int led_02 =24;const int led_03 =25;const int led_10 =26;const int led_11 =27;const int led_12 =28;const int led_13 =29;const int led_20 =30;const int led_21 =31;const int led_22 =32;const int led_23 =33;const int led_30 =34;const int led_31 =35;const int led_32 =36;const int led_33 =37;int led_matrix[4][4] ={ {led_00, led_01, led_02, led_03}, {led_10, led_11, led_12, led_13}, {led_20, led_21, led_22, led_23}, {led_30, led_31, led_32, led_33}} ;//---------- ------------------------------------------- ZONE DE CONFIGURATION ----- -------------------------------------------------- --------------------------configuration void() { RFID.begin(9600); Serial.begin(9600); //modes de lecture (entrée) pour les capteurs à effet Hall pinMode(hes_01, INPUT); pinMode(hes_02, INPUT); pinMode(hes_03, INPUT); pinMode(hes_00, INPUT); pinMode(hes_10, INPUT); pinMode(hes_11, INPUT); pinMode(hes_12, INPUT); pinMode(hes_13, INPUT); pinMode(hes_20, INPUT); pinMode(hes_21, INPUT); pinMode(hes_22, INPUT); pinMode(hes_23, INPUT); pinMode(hes_30, INPUT); pinMode(hes_31, INPUT); pinMode(hes_32, INPUT); pinMode(hes_33, INPUT); //modes d'écriture (sortie) pour les broches LED pinMode(led_00, OUTPUT); pinMode(led_01, SORTIE); pinMode(led_02, SORTIE); pinMode(led_03, SORTIE); pinMode(led_10, SORTIE); pinMode(led_11, SORTIE); pinMode(led_12, SORTIE); pinMode(led_13, SORTIE); pinMode(led_20, SORTIE); pinMode(led_21, SORTIE); pinMode(led_22, SORTIE); pinMode(led_23, SORTIE); pinMode(led_30, SORTIE); pinMode(led_31, SORTIE); pinMode(led_32, SORTIE); pinMode(led_33, SORTIE); read_tags(); retard(1000); first_figure(); retard(1000); Serial.end(); RFID.end(); retard (5000); Serial.begin(9600); retard(1000); RFID.begin(9600); retard(1000); read_tags(); retard (5000); //RFID.flush(); // arrête plusieurs lectures second_figure(); delay(1000);// id_type_matrix[0][2] =2;// id_type_matrix[2][1] =1;}//------------------ ----------------------------------ZONE DE FONCTIONS---------------- ----------------------------------------------//--- ------------------------------------- Suivi d'ID RFID et reconnaissance de figures ------- ----------------------------------------booléen compare_ID(int aa[14], int bb[14]){ booléen ff =faux ; entier fg =0; for (int cc =0; cc <14; cc++) { if (aa[cc] ==bb[cc]) { fg++; } } si (fg ==14) { ff =vrai; } return ff;}int read_tags(){ Serial.println("Placer le chiffre près du lecteur RFID"); retard (5000); RFID.flush(); // arrête plusieurs lectures if (RFID.available()> 0) { delay(300); for (int z =0; z <14; z++) { ID =RFID.read(); nouveau_id[z] =ID ; Serial.println(new_id[z], DEC); retard (500); } } Serial.println("La lecture de l'ID est terminée "); ++ compter ; retard (5000); //il est temps de placer le chiffre sur un tableau et le second devant un lecteur RFIDreturn new_id;}void first_figure() { if (compare_ID(new_id, queen_id) ==true) { Serial.println("QUEEN IS DETECTED" ); for (int s =0; s <=3; s++) { for (int t =0; t <=3; t++) { if (digitalRead(hes_pin_matrix[s][t]) ==0) { id_type_matrix[s ][t] =1; temp_vect[0] =s; temp_vect[1] =t; Serial.print("La reine est placée sur :"); Impression.série(s) ; Serial.println(t); digitalWrite(led_matrix[s][t],HIGH); retard(1000); digitalWrite(led_matrix[s][t],LOW); } } } } else if (compare_ID(new_id, pawn_id) ==true) { Serial.println("PAWN IS DETECTED"); for (int s =0; s <=3; s++) { for (int t =0; t <=3; t++) { if (digitalRead(hes_pin_matrix[s][t]) ==0) { id_type_matrix[s ][t] =2; temp_vect[0] =s; temp_vect[1] =t; Serial.print("Le pion est placé sur :"); Impression.série(s) ; Serial.println(t); digitalWrite(led_matrix[s][t],HIGH); retard(1000); digitalWrite(led_matrix[s][t],LOW); } } } } else { Serial.println("Figure non définie "); }}void second_figure() { if (compare_ID(new_id, queen_id) ==true) { Serial.println("QUEEN IS DETECTED"); for (int s =0; s <=3; s++) { for (int t =0; t <=3; t++) { if (digitalRead(hes_pin_matrix[s][t]) ==0 &&(s !=temp_vect[0] || t !=temp_vect[1])) { id_type_matrix[s][t] =1; Serial.print("La reine est placée sur :"); Impression.série(s) ; Serial.println(t); digitalWrite(led_matrix[s][t],HIGH); retard(1000); digitalWrite(led_matrix[s][t],LOW); } } } } else if (compare_ID(new_id, pawn_id) ==true) { Serial.println("PAWN IS DETECTED"); for (int s =0; s <=3; s++) { for (int t =0; t <=3; t++) { if (digitalRead(hes_pin_matrix[s][t]) ==0 &&(s !=temp_vect[0] || t !=temp_vect[1])) { id_type_matrix[s][t] =2; Serial.print("Le pion est placé sur :"); Impression.série(s) ; Serial.println(t); digitalWrite(led_matrix[s][t],HIGH); retard(1000); digitalWrite(led_matrix[s][t],LOW); } } } }}//--------------------------------------------- ---- TROUVER DES CHIFFRES---------------------------------------------- -----------------------------//fonction supplémentaire pour éteindre les leds uniquement lorsque vous replacez la figure sur le boardvoid leds_off() { int i, j; pour (i =0; i <=3; i++) { pour (j =0; j <=3; j++) { digitalWrite(led_matrix[i][j], LOW); } }}//---------------------------------------------- ---- LA REINE EN MOUVEMENT ------------------------------------------------ -------------------------------------------------- --void move_queen() { int i, j; for (i =empty_pos[0]; i <3;) { digitalWrite(led_matrix[++i][empty_pos[1]], HIGH); //lumière le long d'une ligne verticale } pour (i =empty_pos[0]; i> 0;) { digitalWrite(led_matrix[--i][empty_pos[1]], HIGH); } pour (i =empty_pos[1]; i <3;) { digitalWrite(led_matrix[empty_pos[0]][++i], HIGH); //lumière le long d'une ligne horizontale } pour (i =empty_pos[1]; i> 0;) { digitalWrite(led_matrix[empty_pos[0]][--i], HIGH); } i =pos_vide[0]; j =position_vide[1] ; for (i =i - 3, j =j - 3; i <=3, j <=3; i++, j++) { if (i>=0 &&j>=0 &&i !=empty_pos[0]) { Serial.print(i); Serial.println(j); digitalWrite(led_matrix[i][j], HAUT); } } i =empty_pos[0]; j =position_vide[1] ; for (i =i + 3, j =j - 3; i>=0, j <=3; i--, j++) { if (i>=0 &&i <=3 &&j>=0 &&j <=3 &&i !=empty_pos[0]) { Serial.print(i); Serial.println(j); digitalWrite(led_matrix[i][j], HAUT); } } }//-------------------------------------commencer à lire le nombre de chiffres et enregistrer les positions pour chacun d'eux --------------------------- void figure_reading() { // lit toutes les positions dans une boucle pour détecter la position d'un pion int i, j, found_figure =0;start:found_figure =0; //lire toutes les positions occupées(0) et vides(1) sur le tableau //affecter 0(=carré vide), 1(=carré occupé) à une variable hes_bool_matrix[0][0] =digitalRead(hes_00); hes_bool_matrix[0][1] =digitalRead(hes_01); hes_bool_matrix[0][2] =digitalRead(hes_02); hes_bool_matrix[0][3] =digitalRead(hes_03); hes_bool_matrix[1][0] =digitalRead(hes_10) ; hes_bool_matrix[1][1] =digitalRead(hes_11) ; hes_bool_matrix[1][2] =digitalRead(hes_12); hes_bool_matrix[1][3] =digitalRead(hes_13); hes_bool_matrix[2][0] =digitalRead(hes_20); hes_bool_matrix[2][1] =digitalRead(hes_21); hes_bool_matrix[2][2] =digitalRead(hes_22); hes_bool_matrix[2][3] =digitalRead(hes_23); hes_bool_matrix[3][0] =digitalRead(hes_30); hes_bool_matrix[3][1] =digitalRead(hes_31); hes_bool_matrix[3][2] =digitalRead(hes_32); hes_bool_matrix[3][3] =digitalRead(hes_33); for (i =0; i <=3; i++) { for (j =0; j <=3; j++) { if (hes_bool_matrix[i][j] ==0) { found_figure++; if (found_figure ==1) { if (id_type_matrix[i][j] ==0) { id_type_matrix[i][j] =temp; température =0 ; } if(id_type_matrix[i][j]==1){ Serial.print("La reine est debout :"); Serial.print(i); Serial.println(j); figure_pos[0][0] =i; chiffre_pos[0][1] =j; } else if(id_type_matrix[i][j]==2){ Serial.print("Pawn est debout :"); Serial.print(i); Serial.println(j); figure_pos[0][0] =i; chiffre_pos[0][1] =j; //if (id_type_matrix[i][j] ==0) { //id_type_matrix[i][j] =temp; //temp =0; }} } } else if (found_figure ==2) { if (id_type_matrix[i][j] ==0) { id_type_matrix[i][j] =temp; température =0 ; } if(id_type_matrix[i][j]==1){ Serial.print("La reine est debout :"); Serial.print(i); Serial.println(j); figure_pos[1][0] =i; figure_pos[1][1] =j; //if (id_type_matrix[i][j] ==0) { //id_type_matrix[i][j] =temp; //temp =0; } } else if(id_type_matrix[i][j]==2){Serial.print("Pawn est debout :"); Serial.print(i); Serial.println(j); figure_pos[1][0] =i; figure_pos[1][1] =j;// if (id_type_matrix[i][j] ==0) {// id_type_matrix[i][j] =temp;// temp =0; } //goto out; } } } }} out:if (found_figure ==0 || found_figure ==1) { goto start; } else if (found_figure ==2) { leds_off(); } //---------------------------------------------- nous choisir quel chiffre choisir ---------------------------------------------- -------------------- pos_vide[0] =-1; retard (2000); if (digitalRead(hes_pin_matrix[figure_pos[0][0]][figure_pos[0][1]]) ==1) { empty_pos[0] =figure_pos[0][0]; pos_vide[1] =pos_figure[0][1] ; temp =id_type_matrix[empty_pos[0]][empty_pos[1]] ; id_type_matrix[empty_pos[0]][empty_pos[1]] =0 ; } else if (digitalRead(hes_pin_matrix[figure_pos[1][0]][figure_pos[1][1]]) ==1) { empty_pos[0] =figure_pos[1][0]; pos_vide[1] =pos_figure[1][1] ; temp =id_type_matrix[empty_pos[0]][empty_pos[1]] ; id_type_matrix[empty_pos[0]][empty_pos[1]] =0 ; } //--------------------------------------------------------- PION OU REINE MOBILE -------------------------------------------------- -------------------------------------------------- if(temp==1){ if ( empty_pos[0] !=-1) { move_queen(); aller au début ; } } else if(temp==2){if ( empty_pos[0] !=-1) { if (empty_pos[0] <2) { digitalWrite(led_matrix[empty_pos[0] + 1][empty_pos[1]] , HAUT); digitalWrite(led_matrix[empty_pos[0] + 2][empty_pos[1]], HAUT); } else if (empty_pos[0] ==2) { digitalWrite(led_matrix[empty_pos[0] + 1][empty_pos[1]], HIGH); } autre; } delay(100);} figure_reading();}//------------------------------------ ---------------------------------- la boucle démarre --------------- -------------------------------------------------- -------------------boucle vide() { lecture_figure();}

Schémas