Automated Chess Board

Moves chess pieces around the board invisibly and seemingly magically.

Oct 24, 2018

•

80467 views

•

91 respects

games

robots

Components and supplies

Linear Bearing Block

Medium Density Fiberboard

Arduino UNO

Electromagnet

Steel Rod Stock

Capacitor 100 µF

Acrylic Sheet

Dual H-Bridge motor drivers L298

NEMA 17 Stepper Motor

Stepper motor driver board A4988

Micro Limit Switch

Tools and machines

Hacksaw

Power Drill

Project description

Code

Automated_chessboard

arduino

Code will: *Home magnet with end stops at position A1. *Receive square address (Letter, Number) from Serial Monitor for piece to be moved. *Translate input into number of steps to be completed by stepper motors. *Receive square address (Letter, Number) from Serial Monitor for new piece location. *Turn on electromagnet. *Translate input into number of steps to be completed by stepper motors. *Turn off electromagnet. Notes: *Stepper motors will run simultaneously (during zeroing and moving with the magnet off ) until one reaches its max steps and then the other will continue until it reaches the specified square. *When the magnet is on and moving a piece the steppers initially offset to the corner and moves along the line between squares to prevent pieces interfering with each other. For example, this allows someone to move their knight before moving the pawns in front of it.

1const int stepsBetweenSquares = 318;
2const int stepPinX = 3; 
3const  int dirPinX = 4; 
4const int stepPinY = 5;
5const int dirPinY = 6;
6const  int limitSwitchX = 8;
7const int limitSwitchY = 9;
8const int magnetPinPos =  10;
9const int magnetPinNeg = 11;
10int x1 = 0; int x2 = 1;
11int y1 = 0; int  y2 = 1;
12int xsteps;
13int ysteps;
14int x = 0;
15int y = 0;
16
17void setup()  {
18  Serial.begin(9600);
19  pinMode(stepPinX,OUTPUT); 
20  pinMode(dirPinX,OUTPUT);
21  pinMode(stepPinY,OUTPUT); 
22  pinMode(dirPinY,OUTPUT);
23  pinMode(limitSwitchX,  INPUT);
24  pinMode(limitSwitchY, INPUT);
25  pinMode(magnetPinPos, OUTPUT);
26  pinMode(magnetPinNeg, OUTPUT);
27  
28
29//_________________________________________________________________________________________________
30//  Zero position to square A1
31//--------------------------------------------------------------------------------------------------
32  zeroDiagonal();
33}
34
35
36void loop() {
37//___________________________________________________________________________________________________
38//  Recieve position adress of piece to be moved from Serial monitor (Letter, Number)
39//---------------------------------------------------------------------------------------------------
40  Serial.print("Piece to be moved letter adress:  ");
41  while (!Serial.available());
42    x1 = readSerialLetter();
43      
44  Serial.print("Piece to be moved number  adress:  ");
45  while (!Serial.available());
46    y1 = readSerialNumber();      
47
48
49//______________________________________________________________________________________________
50//  Move to Position of piece to be moved
51//-----------------------------------------------------------------------------------------------
52  xsteps = stepsBetweenSquares*(x1-x2);
53  ysteps = stepsBetweenSquares*(y1-y2);
54  
55  movePieceDiagonal(xsteps, ysteps);
56 
57
58//_______________________________________________________________________________________________
59//  Recieve position adress of piece new location from Serial Monitor (Letter, Number)
60//-----------------------------------------------------------------------------------------------
61  Serial.print("New location letter adress:  ");
62  while (!Serial.available());
63    x2 = readSerialLetter();
64
65  Serial.print("New location number adress:  ");
66  while (!Serial.available());
67    y2 = readSerialNumber();
68  Serial.println();
69
70  
71//________________________________________________________________________________________________
72//  Turn on magnet
73//------------------------------------------------------------------------------------------------
74  digitalWrite(magnetPinPos, HIGH);
75  digitalWrite(magnetPinNeg, LOW);
76
77  
78//________________________________________________________________________________________________
79//  Move piece to new location
80//-------------------------------------------------------------------------------------------------
81  xsteps = stepsBetweenSquares*(x2-x1);
82  ysteps = stepsBetweenSquares*(y2-y1);
83  
84  digitalWrite(dirPinX, HIGH); digitalWrite(dirPinY, LOW);
85  offsetPiece();
86  delay(50);
87  movePiece(xsteps, dirPinX, stepPinX);
88  movePiece(-ysteps,  dirPinY, stepPinY);
89  delay(50);
90  digitalWrite(dirPinX, LOW); digitalWrite(dirPinY,  HIGH);
91  offsetPiece();
92
93//__________________________________________________________________________________________________
94//  Turn off magnet
95//----------------------------------------------------------------------------------------------------
96  digitalWrite(magnetPinPos, LOW);
97  digitalWrite(magnetPinNeg, LOW);
98}
99
100
101/////////////////////////////////////////////////////////////////////////////////////////////////////////
102//  FUNCTIONS ////////////////////////////////////////////////////////////////////////////////////////////
103/////////////////////////////////////////////////////////////////////////////////////////////////////////
104
105int  readSerialLetter(){
106  int i;
107  while(i < 1 || i > 8){
108    i = Serial.read();  
109    i = i - 64;
110    }
111  Serial.println(i);
112  Serial.parseInt();
113  return i;
114  }
115
116//////////////////////////////////////////////////////////////////////////////////////////////////////
117
118int  readSerialNumber(){
119  int i;
120  while (i < 1 || i > 8){
121    i = Serial.parseInt();
122    }
123  Serial.println(i);
124  Serial.parseInt();
125  return i;
126  }
127
128////////////////////////////////////////////////////////////////////////////////////////////////////////
129
130void  zeroDiagonal(){
131  digitalWrite(dirPinX, LOW);
132  digitalWrite(dirPinY, HIGH);
133  while (digitalRead(limitSwitchX) == HIGH && digitalRead(limitSwitchY) == HIGH){
134    moveDiagonal(1.5);
135  }
136  while (digitalRead(limitSwitchX) == HIGH){
137    moveLinear(stepPinX, 1.5);
138  }
139  while (digitalRead(limitSwitchY) == HIGH){
140    moveLinear(stepPinY, 1.5);
141  }
142  while (digitalRead(limitSwitchX) == LOW){         //Backoff switch
143    digitalWrite(dirPinX, HIGH);
144    moveLinear(stepPinX,  1);
145  }
146  while (digitalRead(limitSwitchY) == LOW){         //Backoff switch
147    digitalWrite(dirPinY, LOW);
148    moveLinear(stepPinY, 1);
149  }
150}
151
152///////////////////////////////////////////////////////////////////////////////////////////////////
153
154void  movePiece(int steps, int dirPin, int stepPin){
155  if (steps > 0){
156    digitalWrite(dirPin,HIGH);
157  }
158  else{
159    steps = abs(steps);
160    digitalWrite(dirPin, LOW);
161  }
162  for(int i = 0; i < steps; i++) {
163    moveLinear(stepPin, 2.5);
164  }
165  }
166
167////////////////////////////////////////////////////////////////////////////////////////////////////////
168
169void  movePieceDiagonal(int xsteps, int ysteps){
170  if (ysteps > 0){
171    digitalWrite(dirPinY,  LOW);
172  }
173  else{
174    ysteps = abs(ysteps);
175    digitalWrite(dirPinY,  HIGH);
176  }
177  if (xsteps > 0){
178    digitalWrite(dirPinX, HIGH);
179  } 
180  else{
181    xsteps = abs(xsteps);
182    digitalWrite(dirPinX, LOW);
183  }
184  x = 0; y = 0; 
185  while (x < xsteps && y < ysteps){
186    moveDiagonal(1.5);
187    x++; y++;
188  }
189  for(x; x < xsteps; x++){
190    moveLinear(stepPinX, 1.5);
191  }
192  for(y; y < ysteps; y++){
193    moveLinear(stepPinY, 1.5);
194  }
195}
196
197/////////////////////////////////////////////////////////////////////////////////////////////////////////
198
199void  offsetPiece(){
200  for (int i=0; i < stepsBetweenSquares/2; i++){
201    moveDiagonal(2.5);
202  }
203}
204
205///////////////////////////////////////////////////////////////////////////////////////////////////////////
206
207void  moveDiagonal(int delayTime){
208    digitalWrite(stepPinX, HIGH);
209    digitalWrite(stepPinY,  HIGH);
210    delay(delayTime);
211    digitalWrite(stepPinX, LOW);
212    digitalWrite(stepPinY,  LOW);
213    delay(delayTime);
214}
215
216////////////////////////////////////////////////////////////////////////////////////////////////////////////////
217
218void  moveLinear(int stepPin, int delayTime){
219  digitalWrite(stepPin, HIGH);
220  delay(delayTime);
221  digitalWrite(stepPin, LOW);
222  delay(delayTime);
223}

const int stepsBetweenSquares = 318;
const int stepPinX = 3; 
const  int dirPinX = 4; 
const int stepPinY = 5;
const int dirPinY = 6;
const  int limitSwitchX = 8;
const int limitSwitchY = 9;
const int magnetPinPos =  10;
const int magnetPinNeg = 11;
int x1 = 0; int x2 = 1;
int y1 = 0; int  y2 = 1;
int xsteps;
int ysteps;
int x = 0;
int y = 0;

void setup()  {
  Serial.begin(9600);
  pinMode(stepPinX,OUTPUT); 
  pinMode(dirPinX,OUTPUT);
  pinMode(stepPinY,OUTPUT); 
  pinMode(dirPinY,OUTPUT);
  pinMode(limitSwitchX,  INPUT);
  pinMode(limitSwitchY, INPUT);
  pinMode(magnetPinPos, OUTPUT);
  pinMode(magnetPinNeg, OUTPUT);
  

//_________________________________________________________________________________________________
//  Zero position to square A1
//--------------------------------------------------------------------------------------------------
  zeroDiagonal();
}


void loop() {
//___________________________________________________________________________________________________
//  Recieve position adress of piece to be moved from Serial monitor (Letter, Number)
//---------------------------------------------------------------------------------------------------
  Serial.print("Piece to be moved letter adress:  ");
  while (!Serial.available());
    x1 = readSerialLetter();
      
  Serial.print("Piece to be moved number  adress:  ");
  while (!Serial.available());
    y1 = readSerialNumber();      


//______________________________________________________________________________________________
//  Move to Position of piece to be moved
//-----------------------------------------------------------------------------------------------
  xsteps = stepsBetweenSquares*(x1-x2);
  ysteps = stepsBetweenSquares*(y1-y2);
  
  movePieceDiagonal(xsteps, ysteps);
 

//_______________________________________________________________________________________________
//  Recieve position adress of piece new location from Serial Monitor (Letter, Number)
//-----------------------------------------------------------------------------------------------
  Serial.print("New location letter adress:  ");
  while (!Serial.available());
    x2 = readSerialLetter();

  Serial.print("New location number adress:  ");
  while (!Serial.available());
    y2 = readSerialNumber();
  Serial.println();

  
//________________________________________________________________________________________________
//  Turn on magnet
//------------------------------------------------------------------------------------------------
  digitalWrite(magnetPinPos, HIGH);
  digitalWrite(magnetPinNeg, LOW);

  
//________________________________________________________________________________________________
//  Move piece to new location
//-------------------------------------------------------------------------------------------------
  xsteps = stepsBetweenSquares*(x2-x1);
  ysteps = stepsBetweenSquares*(y2-y1);
  
  digitalWrite(dirPinX, HIGH); digitalWrite(dirPinY, LOW);
  offsetPiece();
  delay(50);
  movePiece(xsteps, dirPinX, stepPinX);
  movePiece(-ysteps,  dirPinY, stepPinY);
  delay(50);
  digitalWrite(dirPinX, LOW); digitalWrite(dirPinY,  HIGH);
  offsetPiece();

//__________________________________________________________________________________________________
//  Turn off magnet
//----------------------------------------------------------------------------------------------------
  digitalWrite(magnetPinPos, LOW);
  digitalWrite(magnetPinNeg, LOW);
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  FUNCTIONS ////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////

int  readSerialLetter(){
  int i;
  while(i < 1 || i > 8){
    i = Serial.read();  
    i = i - 64;
    }
  Serial.println(i);
  Serial.parseInt();
  return i;
  }

//////////////////////////////////////////////////////////////////////////////////////////////////////

int  readSerialNumber(){
  int i;
  while (i < 1 || i > 8){
    i = Serial.parseInt();
    }
  Serial.println(i);
  Serial.parseInt();
  return i;
  }

////////////////////////////////////////////////////////////////////////////////////////////////////////

void  zeroDiagonal(){
  digitalWrite(dirPinX, LOW);
  digitalWrite(dirPinY, HIGH);
  while (digitalRead(limitSwitchX) == HIGH && digitalRead(limitSwitchY) == HIGH){
    moveDiagonal(1.5);
  }
  while (digitalRead(limitSwitchX) == HIGH){
    moveLinear(stepPinX, 1.5);
  }
  while (digitalRead(limitSwitchY) == HIGH){
    moveLinear(stepPinY, 1.5);
  }
  while (digitalRead(limitSwitchX) == LOW){         //Backoff switch
    digitalWrite(dirPinX, HIGH);
    moveLinear(stepPinX,  1);
  }
  while (digitalRead(limitSwitchY) == LOW){         //Backoff switch
    digitalWrite(dirPinY, LOW);
    moveLinear(stepPinY, 1);
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////

void  movePiece(int steps, int dirPin, int stepPin){
  if (steps > 0){
    digitalWrite(dirPin,HIGH);
  }
  else{
    steps = abs(steps);
    digitalWrite(dirPin, LOW);
  }
  for(int i = 0; i < steps; i++) {
    moveLinear(stepPin, 2.5);
  }
  }

////////////////////////////////////////////////////////////////////////////////////////////////////////

void  movePieceDiagonal(int xsteps, int ysteps){
  if (ysteps > 0){
    digitalWrite(dirPinY,  LOW);
  }
  else{
    ysteps = abs(ysteps);
    digitalWrite(dirPinY,  HIGH);
  }
  if (xsteps > 0){
    digitalWrite(dirPinX, HIGH);
  } 
  else{
    xsteps = abs(xsteps);
    digitalWrite(dirPinX, LOW);
  }
  x = 0; y = 0; 
  while (x < xsteps && y < ysteps){
    moveDiagonal(1.5);
    x++; y++;
  }
  for(x; x < xsteps; x++){
    moveLinear(stepPinX, 1.5);
  }
  for(y; y < ysteps; y++){
    moveLinear(stepPinY, 1.5);
  }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////

void  offsetPiece(){
  for (int i=0; i < stepsBetweenSquares/2; i++){
    moveDiagonal(2.5);
  }
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////

void  moveDiagonal(int delayTime){
    digitalWrite(stepPinX, HIGH);
    digitalWrite(stepPinY,  HIGH);
    delay(delayTime);
    digitalWrite(stepPinX, LOW);
    digitalWrite(stepPinY,  LOW);
    delay(delayTime);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void  moveLinear(int stepPin, int delayTime){
  digitalWrite(stepPin, HIGH);
  delay(delayTime);
  digitalWrite(stepPin, LOW);
  delay(delayTime);
}

Downloadable files

Automated_chessboard_Layout

Board powered from USB cable for all logic devices. Steppers and electromagnet (Solenoid) are powered from external power brick that is 9 volts and max 5 amps.

Automated_chessboard_Layout

Board powered from USB cable for all logic devices. Steppers and electromagnet (Solenoid) are powered from external power brick that is 9 volts and max 5 amps.

Automated_chessboard_Layout

Comments

Only logged in users can leave comments

maguerero

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content