Elektronisches Schachbrett (4x4 Demo-Prototyp)

Notwendige Werkzeuge und Maschinen

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Hallo Macher,

Ich bin Tahir Miriyev, Absolvent 2018 der Middle East Technical University, Ankara/Türkei. Ich habe Angewandte Mathematik als Hauptfach studiert, aber ich habe es immer geliebt, Dinge zu machen, besonders wenn es um Handarbeit mit Elektronik, Design und Programmierung ging. Dank eines einzigartigen Kurses zum Thema Prototyping, der an unserer Abteilung für Industriedesign angeboten wird, hatte ich die Möglichkeit, etwas wirklich Interessantes zu machen. Das Projekt kann als Semesterprojekt behandelt werden, das für die Dauer eines ganzen Semesters (4 Monate) dauert. Die Studierenden hatten die Aufgabe, einen kreativen Ansatz zu finden, um bereits bestehende Produkte/Demos zu entwerfen und ihre Ideen mit Arduino-Mikrocontrollern und -Sensoren zu verwirklichen. Ich dachte über Schach nach und nachdem ich einige erfolgreiche Projekte recherchiert hatte, bemerkte ich, dass die Macher in früheren Projekten im Wesentlichen fertige Schachengines verwendet haben (wo alle Züge jeder Figur im Kern programmiert waren), zusammen mit Raspberry Pi, einigen MUXes , LEDs und Reed-Schalter. In meinem Projekt entschied ich mich jedoch, jegliche externe Software im Sinne einer Schachengine loszuwerden und eine kreative Lösung für das Figurenerkennungsproblem zu finden, unter Verwendung von RFID-Lesegeräten, Hall-Effekt-Sensoren und Arduino Mega.

Um es einfach auszudrücken, nehmen Sie an, Sie haben ein Schachbrett mit einem "Gehirn" =Mikrocontroller, und Sie müssen Ihrem Brett klar machen, welche Figur Sie in der Hand gehalten haben und wo Sie sie platziert haben. Dies ist das Problem der Figurenerkennung. Die Lösung dieses Problems ist trivial, wenn Sie eine Schachengine haben, bei der alle Figuren auf ihren ursprünglichen Positionen auf dem Brett stehen. Bevor ich erkläre, warum das so ist, lassen Sie mich einige Bemerkungen machen.

Für diejenigen, die davon begeistert sind, wie die Dinge hier funktionieren, muss ich klarstellen, warum wir Reedschalter brauchen (oder in meinem Fall habe ich Hall-Effekt-Sensoren verwendet):Wenn Sie einen Magneten unter jedes Teil legen und es von einer Quadrat auf dem Brett (vorausgesetzt, dass sich unter jedem Quadrat ein Reed-Schalter befindet) aufgrund des Vorhandenseins/Nichtvorhandenseins des Magnetfelds über dem Sensor können Sie Ihrem Controller klar machen, ob auf dem Quadrat eine Figur steht oder nicht. Es sagt dem Mikrocontroller jedoch immer noch nichts darüber aus, welches Stück genau auf dem Platz steht. Es sagt nur, dass sich auf einem Feld ein Stein befindet/keinen Stein. An dieser Stelle stehen wir vor einem Figurenerkennungsproblem, das mit einer Schachengine gelöst werden kann, bei der alle Figuren zu Beginn des Schachspiels auf ihre Ausgangspositionen gesetzt werden. Auf diese Weise "weiß" der Mikrocontroller von Anfang an, wo jedes Stück steht, mit allen Adressen im Speicher. Dies bringt uns jedoch eine große Einschränkung mit sich:Sie können nicht beliebig viele Steine ​​​​wählen und zufällig irgendwo auf dem Brett platzieren und mit der Analyse des Spiels beginnen. Sie müssen immer von vorne beginnen, alle Steine ​​​​sollten sich ursprünglich auf dem Brett befinden, da der Mikrocontroller nur so ihre Position verfolgen kann, sobald Sie einen Stein angehoben und auf ein anderes Feld gelegt haben. Im Wesentlichen war dies das Problem, das ich bemerkte und auf das ich hinarbeiten wollte.

Meine Lösung war ziemlich einfach, wenn auch kreativ. Ich habe einen RFID-Leser auf die Vorderseite einer Platine gelegt. Inzwischen habe ich nicht nur einen Magneten unter den Stücken angebracht, sondern auch einen RFID-Tag, wobei jedes Stück eine einzigartige ID hat. Bevor Sie also eine Figur auf ein beliebiges Quadrat stellen, können Sie das Stück zunächst nahe an den RFID-Leser halten und diesen die ID lesen lassen, das Stück identifizieren, im Speicher ablegen und dann an einer beliebigen Stelle platzieren. Anstatt Reed-Schalter zu verwenden, habe ich zur Vereinfachung des Schaltungsdesigns Hall-Effekt-Sensoren verwendet, die ähnlich funktionieren, mit dem einzigen Unterschied, dass sie 0 oder 1 als digitale Daten an einen Mikrocontroller senden, was "da ist" bedeutet oder "es gibt" keine Figur auf dem Quadrat. Ich habe auch LEDs hinzugefügt (leider nicht die gleiche Farbe, hatte keine), damit beim Anheben des Teils alle quadratischen Stellen leuchten, an denen ein angehobenes Teil platziert werden könnte. Betrachten Sie es als eine pädagogische Übung für Schachlerner:)

Abschließend möchte ich anmerken, dass das Projekt trotz der Tatsache, dass ich mehrere Techniken verwendet habe, einfach und verständlich bleibt, nicht tief ausgearbeitet oder zu kompliziert. Ich hatte nicht genug Zeit, um mit 8x8-Schachbrett fortzufahren (auch weil 64 Hall-Effekt-Sensoren in der Türkei teuer sind, habe ich alle Kosten im Zusammenhang mit dem Projekt übernommen), deshalb habe ich eine 4x4-Demoversion mit nur zwei getesteten Teilen gemacht:Bauer und Dame . Anstatt eine Schachengine zu verwenden, habe ich einen Quellcode für Arduino geschrieben, der alles generiert.

Bevor wir zur Schritt-für-Schritt-Anleitung übergehen Erklärung, wie das Projekt durchgeführt wurde, würde ich empfehlen, ein anschauliches Video anzuschauen und eine intuitive Vorstellung davon zu bekommen, worüber ich spreche.

Hinweis Nr. 1:Eine der roten LEDs (erste in der Reihe / von links nach rechts) ist durchgebrannt, egal.

Hinweis #2:Obwohl weit verbreitet, kann ich aus meiner Erfahrung sagen, dass die RFID-Technologie nicht die beste Idee für Heimwerkeranwendungen ist (natürlich wenn Sie Alternativen haben). Bevor alles funktionierte, habe ich viele Versuche unternommen, Schachfiguren in der Nähe des Lesers zu platzieren und zu warten, bis er die ID korrekt liest. Dafür sollte die serielle Schnittstelle eingerichtet werden, da die Art und Weise, wie der RFID-Leser die ID liest, nur Kopfschmerzen bereitet. Man sollte es selbst versuchen, um das Problem zu verstehen.

Hier ist die Liste aller Tools Ich habe für das Projekt verwendet:

Elektronische Komponenten:

• Steckbrett (x1)

• Omnidirektionale A1126LUA-T (IC-1126 SW OMNI 3-SIP ALLEGRO) Hall-Effekt-Sensoren (x16)

• Einfache 5 mm LEDs (x16)

• Überbrückungsdrähte

• 125-kHz-RFID-Lesegerät und Antenne (x1)

• Arduino Mega (x1)

• RFID-3M-Tags (x2)

Andere Materialien:

• Plexiglas

• Glanzpapier

• kurze Bretter (Holz)

• Acrylfarbe (Dunkelgrün und Creme) x2

• Dünner Karton

• 10 mm Rundmagnete (x2)

• Bauern- und Damenfiguren

• Lötkolben und Lötmaterial

Zeit zu erklären, wie die Dinge gemacht wurden. Bitte folgen Sie der Schritt-für-Schritt-Beschreibung:

1. Nehmen Sie einen 21x21 cm großen Karton, sowie etwas zusätzlichen Karton, um die Wände des oberen Teils des Brettes zu schneiden und zu kleben, um 16 Quadrate mit A B C D 1 2 3 4 aufgezählt zu machen. Da Karton dünn ist, können Sie in jedes Quadrat 16 Hall-Effekt-Sensoren mit jeweils 3 Beinen und 16 LEDs mit jeweils 2 Beinen kleben.

2. Nachdem Sie die Komponenten eingestellt haben, müssen Sie etwas löten, um die Beine von Hall-Effekt-Sensoren und LEDs an die Drahtbrücken zu löten. An dieser Stelle würde ich empfehlen, farbige Drähte geschickt auszuwählen, damit Sie nicht mit den + und - Beinen von LEDs, auch VCC-, GND- und PIN-Beinen von Hall-Effekt-Sensoren, verwechselt werden. Natürlich könnte man eine Platine mit Sensoren und sogar bereits gelöteten LEDs vom Typ WS2812 drucken, aber ich entschied mich, das Projekt einfach zu halten und mehr "Handarbeit" zu machen. An dieser Stelle müssen Sie nur noch Kabel und Sensoren vorbereiten. In späteren Phasen können Sie nach dem Fritzing-Schema sehen, wo Sie das Ende jedes Drahts anbringen sollten. In Kürze werden einige von ihnen direkt zu den PINs auf dem Arduino Mega gehen (es gibt genug davon auf dem Arduino), andere zum Steckbrett und alle GNDs können an ein einziges Stück Kabel gelötet werden (wodurch eine gemeinsame Masse entsteht), was später sollte mit dem GND auf dem Arduino-Board verbunden werden. Ein wichtiger Hinweis hier:Hall-Effekt-Sensoren sind OMNIDIRECTIONAL, was bedeutet, dass es egal ist, welcher Pol eines Magneten in der Nähe des Sensors gehalten wird. nämlich, der Magnet ist vom Sensor entfernt (weiter als sagen wir 5 sm).

3. Bereiten Sie einen ähnlichen 21x21 cm großen Karton vor und befestigen Sie den Arduino Mega und ein langes Steckbrett darauf. Sie können auch wieder 4 Wände beliebiger Höhe aus Karton zuschneiden und mit diesen beiden Lagen quadratischer Bretter 21x21 cm vertikal verkleben. Folgen Sie dann Fritzing Schematics, um die Dinge einzurichten. Sie können den RFID-Leser auch einstellen, nachdem Sie mit LEDs und Hall-Effekt-Sensoren fertig sind.

4. Testen Sie, ob alle LEDs und Sensoren funktionieren, indem Sie Signale mit Basiscodes senden. Vermeiden Sie diesen Schritt nicht, da Sie so testen können, ob alles richtig funktioniert, und zum weiteren Aufbau des Boards übergehen.

5. Bereiten Sie Bauer und Dame vor, indem Sie unten zwei Magnete mit einem Radius von 10 cm sowie runde RFID-Tags anbringen. Später müssen Sie die IDs dieser Tags vom Serial Screen auf der Arduino IDE lesen.

6. Wenn alles gut funktioniert, können Sie den Hauptcode starten und Dinge ausprobieren!

7 (wahlweise). Sie können mit Holz künstlerisch arbeiten, um Ihrer Demo ein natürlicheres Aussehen zu verleihen. Das liegt an Ihrem Willen und Ihrer Vorstellungskraft.

Hier sind einige Videos und Fotos aus verschiedenen Phasen:

Danke für Ihre Aufmerksamkeit! Testen Sie alles und schreiben Sie in den Kommentaren alle Arten von Fehlern, die ich übersehen habe, Verbesserungen, Vorschläge usw. Ich freue mich darauf, einige Meinungen über das Projekt zu hören .com) oder fügen Sie Skype hinzu (tahir.miriyev9r1), damit wir ein Gespräch planen und die Dinge im Detail besprechen können. Viel Glück!

Code

• thinK_code.ino

thinK_code.inoArduino

#include SoftwareSerial RFID(11, 12);//----------------------------------------------------------- ------------ ANFANG ------------------------------------- -------------------------------------------------- ------int empty_pos[2];int figure_pos[2][2]; //Denken an eine Figurenposition als Matrix aus zwei Vektoren (Königin und Bauer) mit drei Einträgen (x Pos, y Pos und Wert 1(Königin), 2(Bauer)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]; //Anfangsmatrix für Hall-Effekt-Sensorenint hes_bool_matrix[4][4];// Liste der Hall-Effekte Sensorpins auf 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, er 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 int led_00 =2201 . inst =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}}; // ---------- ------------------------------------------------------- EINRICHTUNGSBEREICH ----- -------------------------------------------------- --------------------------void setup () { RFID.begin (9600); Serial.begin (9600); // Lesemodi (Eingang) für Hall-Effekt-Sensoren 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); // Schreibmodi (Ausgabe) für LED-Pins PinMode (led_00, OUTPUT); pinMode (led_01, AUSGANG); pinMode (led_02, AUSGANG); pinMode (led_03, AUSGANG); pinMode (led_10, AUSGANG); pinMode (led_11, AUSGANG); pinMode (led_12, AUSGANG); pinMode (led_13, AUSGANG); pinMode (led_20, AUSGANG); pinMode (led_21, AUSGANG); pinMode (led_22, AUSGANG); pinMode (led_23, AUSGANG); pinMode (led_30, AUSGANG); pinMode (led_31, AUSGANG); pinMode (led_32, AUSGANG); pinMode (led_33, AUSGANG); read_tags(); Verzögerung (1000); first_figure(); Verzögerung (1000); Serial.end(); RFID.end(); Verzögerung (5000); Serial.begin (9600); Verzögerung (1000); RFID.begin (9600); Verzögerung (1000); read_tags(); Verzögerung (5000); //RFID.flush(); // stoppt mehrere Lesevorgänge second_figure(); delay(1000);// id_type_matrix[0][2] =2;// id_type_matrix[2][1] =1;}//----------------- ----------------------------------BEREICH DER FUNKTIONEN -------------- ---------------------------------------------------------- //--- --------------------------RFID-ID-Tracking und Figurenerkennung ------- ----------------------------------------boolescher Vergleichs_ID(int aa[14], int bb[14]){ boolesch ff =false; int fg =0; for (int cc =0; cc <14; cc++) { if (aa[cc] ==bb[cc]) { fg++; }} if (fg ==14) {ff =wahr; } return ff;}int read_tags () { Serial.println ( "Platzieren Sie die Figur in der Nähe des RFID-Lesers"); Verzögerung (5000); RFID.flush(); // stoppt mehrere Lesevorgänge if (RFID.available ()> 0) { delay (300); for (int z =0; z <14; z++) { ID =RFID.read(); neue_id[z] =ID; Serial.println (new_id[z], DEC); Verzögerung (500); } } Serial.println ("ID-Lesen ist abgeschlossen"); ++zählen; Verzögerung (5000); // Zeit, die Figur auf ein Brett zu legen und die zweite vor einen RFID-Readerreturn 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 ( "Queen wird platziert auf:"); Seriendruck(e); Serial.println (t); digitalWrite(led_matrix[s][t],HIGH); Verzögerung (1000); digitalWrite(led_matrix[s][t],LOW); aufrechtzuerhalten. aufrechtzuerhalten. 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 ( "Bauer wird platziert auf:"); Seriendruck(e); Serial.println (t); digitalWrite(led_matrix[s][t],HIGH); Verzögerung (1000); digitalWrite(led_matrix[s][t],LOW); } } } } else { Serial.println ( "Undefinierte Zahl"); }}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 ( "Queen wird platziert auf:"); Seriendruck(e); Serial.println (t); digitalWrite(led_matrix[s][t],HIGH); Verzögerung (1000); digitalWrite(led_matrix[s][t],LOW); aufrechtzuerhalten. aufrechtzuerhalten. 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 ( "Bauer wird platziert auf:"); Seriendruck(e); Serial.println (t); digitalWrite(led_matrix[s][t],HIGH); Verzögerung (1000); digitalWrite(led_matrix[s][t],LOW); } } } }} //------------------------------------------ ---- FINDEN VON ZAHLEN ------------------------------------------ ------------------------------------------ // Extra-Funktion zum Ausschalten der LEDs nur, wenn Sie die Figur wieder auf das Boardvoidleds_off() legen {int i, j; für (i =0; i <=3; i++) { für (j =0; j <=3; j++) { digitalWrite (led_matrix[i][j], LOW); } }} //--------------------------------------------------------- ----BEWEGENDE KÖNIGIN-------------------------------------------- -------------------------------------------------- --void move_queen() { int i, j; for (i =empty_pos[0]; i <3;) { digitalWrite(led_matrix[++i][empty_pos[1]], HIGH); // Licht entlang einer vertikalen Linie} for (i =empty_pos [0]; i> 0;) { digitalWrite (led_matrix[--i][empty_pos[1]], HIGH); } for (i =empty_pos[1]; i <3;) { digitalWrite(led_matrix[empty_pos[0]][++i], HIGH); // Licht entlang einer horizontalen Linie} for (i =empty_pos[1]; i> 0;) {digitalWrite(led_matrix[empty_pos[0]][--i], HIGH); } i =empty_pos[0]; j =leere_pos[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], HIGH); } } i =empty_pos[0]; j =leere_pos[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], HIGH); } } } //-------------------------------------------------Anzahl der Ziffern lesen und Positionen speichern für jeden von ihnen --------------------------void figure_reading () { //alle Positionen in einer Schleife lesen, um die Position eines Bauern zu erkennen int i, j, gefundene_figur =0;start:gefundene_figur =0; // alle belegten (0) und leeren (1) Positionen auf der Platine lesen // 0 (=leeres Quadrat), 1 (=belegtes Quadrat) einer Variablen zuweisen 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; Temperatur =0; } if(id_type_matrix[i][j]==1){Serial.print("Queen steht auf:"); Serial.print (i); Serial.println(j); figure_pos[0][0] =ich; figure_pos[0][1] =j; aufrechtzuerhalten. Sonst if (id_type_matrix[i][j]==2) {Serial.print("Bauer steht auf:"); Serial.print (i); Serial.println(j); figure_pos[0][0] =ich; figure_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; Temperatur =0; } if(id_type_matrix[i][j]==1){Serial.print("Queen steht auf:"); Serial.print (i); Serial.println(j); figure_pos[1][0] =ich; 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("Bauer steht auf:"); Serial.print (i); Serial.println(j); figure_pos[1][0] =ich; figure_pos[1][1] =j;// if (id_type_matrix[i][j] ==0) {// id_type_matrix[i][j] =temp;// temp =0; } //ausgehen; } } } }} out:if (found_figure ==0 || found_figure ==1) { goto start; aufrechtzuerhalten. Sonst if (found_figure ==2) {leds_off (); } //---------------------------------------------- wir Wählen Sie aus, welche Figur Sie auswählen möchten ------------------------------------------------------ -------------------- empty_pos[0] =-1; Verzögerung (2000); if (digitalRead(hes_pin_matrix[figure_pos[0][0]][figure_pos[0][1]]) ==1) { empty_pos[0] =figure_pos[0][0]; empty_pos[1] =figure_pos[0][1]; temp =id_type_matrix[empty_pos[0]][empty_pos[1]]; id_type_matrix[leere_pos[0]][leere_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]; leere_pos[1] =figure_pos[1][1]; temp =id_type_matrix[empty_pos[0]][empty_pos[1]]; id_type_matrix[leere_pos[0]][leere_pos[1]] =0; } //------------------------------------------- BEWEGUNGSBAUER oder KÖNIGIN -------------------------------------------------- -------------------------------------------------- if(temp==1){ if ( empty_pos[0] !=-1) { move_queen(); gehe zum Start; } } else if(temp==2){if ( empty_pos[0] !=-1) { if (empty_pos[0] <2) { digitalWrite(led_matrix[empty_pos[0] + 1][empty_pos[1]] , HOCH); digitalWrite(led_matrix[empty_pos[0] + 2][empty_pos[1]], HIGH); aufrechtzuerhalten. Sonst if (empty_pos[0] ==2) { digitalWrite(led_matrix[empty_pos[0] + 1][empty_pos[1]], HIGH); } anders; } delay(100);} figure_reading();}//------------------------------------------------ ---------------------------------- Schleife beginnt -------------- -------------------------------------------------- -------------------void loop() { figure_reading();}

Schaltpläne