Here you can find the code for the move visualizing LEDs
/**
* Serial communication between the Arduino and the
* computer running python. (see other code)
*
* The arduino sends a '1' to tell the computer when the
* user has done his move. PC makes what he has to do and
* sends 4 charachers through the serial port. With that
* the arduino moves the motors such that the piece is
* moved.
*/
//========================================================
// Includes
//========================================================
#include <LiquidCrystal.h>
//========================================================
// Pin Definitions
//========================================================
#define LED 13
#define LCD_BUTTON 0
#define MOVE_MADE '1'
#define MOVE_UNDO '2'
#define INVALID_MOVE "3"
/* The following macros are needed in order to allow the pc
play a sound when its pions are moving
The arduino sends either MOCE_DONE or DOING_MOVE so that
the PC is synchronized with the arduino and only plays a
sound when the piece is actually moving or not
*/
#define MOVE_DONE '4'
#define DOING_MOVE '5'
int dataPin = 12; //Serial Output to Shift Register
int latchPin = 11; //Shift Register Latch Pin
int clockPin = 10; //Shift Register Clock Pin
// not sure about these pin numbers
int magnetPin = 2; // arduino pin for the electromagnet
//========================================================
// variables
//========================================================
//boolean moveReceived = false;
boolean moveReceived = true; // just to test
long t = 0;
int analog;
String nextMove = "";
String prevMove = "";
String data;
int dir[2];
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //Associtae PINS to LCD
// globally defined array size
int array_size; //way to do it: http://arduino.stackexchange.com/questions/3774/how-can-i-declare-an-array-of-variable-size-globally
int arrayTrajectory[16]={
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // max 8 steps on a location with a certain row and column number: 8x2=16
// introduce offsets because shift registers are cascaded as: arduino - anode (24-16) - cathode (15-7) - motors (6-1) and their corresponding numbers
int SR2Offset=8; // the first 8 bits that will be shifted into the shift registers
int SR3Offset=SR2Offset+8;
int cathodeOffset=6;
int anodeOffset=15;
unsigned long timer1;//StepTrajectory; // "ALWAYS use unsigned long for timers, not int"
unsigned long timer2;//timer2Move2BeginPos; //
// maybe even make another for diagonal trajectoy (will take longer because of longer distance)
int index=-1; // corresponds to the (number of moves)*2 that have been completed of the desired trajectory
int time1Step=10000UL; // in milliseconds, to go with motors from 1 square to the next, assume 1 second= 1000ms
// begin step= 10s= 10000ms
//the "UL" after the number is a syntax detail that is important when
//dealing with large numbers in millis and micros
void setup() {
Serial.begin(9600);
pinMode(LED,OUTPUT);
/* just so I have enough time to lauch the python
script to communicate arduino will wait 20 sec */
//delay(20000);
pinMode(dataPin, OUTPUT);
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(magnetPin, OUTPUT);
// int myTest1[8]={1,2,3,4,5,6,0,0}; // 8 , 1-8
// valueShiftOut(myTest1);
// int myTest2[8]={9,10,0,0,0,0,0,0}; //3 , 9-16
// valueShiftOut(myTest2);
// int myTest3[8]={17,18,0,0,0,0,0,0};//2 , 17, 24
// valueShiftOut(myTest3);
digitalWrite(latchPin,LOW);
}
void loop() {
// TESTS:
// digitalWrite(latchPin,LOW);
// int myTest1[8]={1,2,3,4,5,6,7,8}; // 8 , 1-8
// valueShiftOut(myTest1);
// int myTest2[8]={0,0,0,0,0,0,0,16}; //3 , 9-16
// valueShiftOut(myTest2);
// int myTest3[8]={17,0,0,0,0,0,0,0};//2 , 17, 24
// valueShiftOut(myTest3);
// digitalWrite(latchPin,HIGH);
// Trajectories:
int myPositions1[4]={
8,8,1,1 }; // just to test, have to convert strng nextMove to an array of 4.
int myPositions2[4]={
4,1,4,8 };
int myPositions3[4]={
4,5,6,6 };
if (moveReceived) { // To Be executed when move has been received
//reconstruct total trajectory:
int trajectoryLength=trajectory(myPositions1,arrayTrajectory); // only usefull length (without from all the 0s)
Serial.println(trajectoryLength);
// Serial.println("BEGIN");
// for (int i=0; i < 8; i++){
// Serial.println(arrayTrajectory[i]);
// }
// Serial.println("END");
if(index==-1){ // so a move is received, but not started yet
// go with motor to the begin position (motor can be far away from place), wait long enough, so we can start the trajectory afterwards where motor and LEDS are synchronous (moving at same location and same speed)
//delay(10000); not got to use, we use another timer for it! otherwise we can't do other things like displays on LCD
timer2=millis(); // start time of moving from initial pos towards begin pos in trajectory/array
index=0;// we will soon arrive at begin pos of array, next loop, we get in the enxt if statement if time has passed to get there
// !write here the code to really move to begin pos of array with the motors: use time for 1 step, use number of steps to do
String string4 = "we now start to move from an arbitrary pos to the first pos of the trajectory";
Serial.println(string4);
//Serial.println(timer2);
movePiece1Step(index);
}
if(((millis()-timer2)>7000UL)&&index==0){ // change timing depding on time needed for 1 step and multiply by the number of steps you need
//we can start the first move: going from begin pos to second pos in array, here we ligh up the first square as long as pion didn't reach second square
String string3 = "we now start the first move of the trajectory";
Serial.println(string3);
index=2; //when move is done and when we arrive at begin pos of the array, we can start next move in array
movePiece1Step(index); //keeps moving/lighting untill you ask for a second move
timer1=millis(); // starting time of first move in array
digitalWrite(latchPin,HIGH);
}
if(((millis()-timer1)>3000UL*index/2)&&index>1){ //index=2 ==> 5s, index=5 ==> 10s, index=6==> 15s
index=index+2;
movePiece1Step(index); //keeps moving/lighting untill you ask for a next move
String stringOne = "ith step of trajectory has been completed";
String stringindex = String(index);
//Serial.println(stringOne);
//Serial.println(stringindex);
digitalWrite(latchPin,HIGH);
}
// String string2 = String(index);
// Serial.println(string2);
// if(index>trajectoryLength-1){ // all moves in trajectory are completed
// for(
// digitalWrite(latchPin,LOW);
// index=-1; //when move is done and when we arrive at begin pos of the array
// moveReceived = false; // this can maybe go away after test
// String string2 = "trajectory is finished";
// Serial.println(string2);
// }
}
}
//==========================================================
// Helper functions/methods
//==========================================================
void movePiece1Step(int index) { // if only motors/ leds give extra boolean as input :-) also add magnet boolean to determine if magnet is needed or not (it is needed if it is doing trajectory movement, not for first movement)
/* this is the method where we would put the control for the
motors to move the piece from nextMove[0:1] to
nextMove[2:3].
For now we simply light a the LED
*/
// TODO : put here code to decode the move so that it can be
// interpreted
// for sure first 6 motor bits to send
// led:
int row1=arrayTrajectory[index]+cathodeOffset;
int column1=arrayTrajectory[index+1]+anodeOffset;
int row2=row1+1; // for the LED square
int column2=column1+1; // for the LED square
// motor bits (no offset): which have to be turned on?
//Serial.println(row1);
//Serial.println(column1);
int listValues[]={
row1,row2,column1,column2 }; // and motor bits still to add
// int arrSize = sizeof( listValues )/ sizeof( int );
// Serial.println(sizeof( listValues ));
// Serial.println(sizeof( int )); ===> this doesn't work in for loop...
int arrSize =4;// take 4 now because 4 bits for LED, afterwards add motor bits (+6) ==> 10
int indexSR1=0;
int indexSR2=0;
int indexSR3=0;
// could make SR1 max 8, SR2 max 3 (1 anode, 2 cathode), SR3 max 2 (2 anodes)
int SR1[8]={
0,0,0,0,0,0,0,0 }; // Numbers from 1-8, zeros to not have arbitrary values in unfilled places
int SR2[8]={
0,0,0,0,0,0,0,0 }; // Numbers from 9-16, zeros to not have arbitrary values in unfilled places
int SR3[8]={
0,0,0,0,0,0,0,0 }; // Numbers from 17-24, zeros to not have arbitrary values in unfilled places
//Serial.println(arrSize);
// fill the SR arrays by looking at the corresponding numbers:
for(int i=0; i < arrSize; i++){
//Serial.println(i);
if((listValues[i]>0)&&(listValues[i]<9)){
SR1[indexSR1]=listValues[i];
indexSR1=indexSR1+1;
}
else if((listValues[i]>8)&&(listValues[i]<17)){
SR2[indexSR2]=listValues[i];
indexSR2=indexSR2+1;
}
else if((listValues[i]>16)&&(listValues[i]<25)){
SR3[indexSR3]=listValues[i];
indexSR3=indexSR3+1;
}
// //neglect the unfilled places
}
// Serial.println("SR1:");
// for (int i=0; i < 8; i++){
// Serial.println(SR1[i]);
// }
//
// Serial.println("SR2:");
// for (int i=0; i < 8; i++){
// Serial.println(SR2[i]);
// }
//
// Serial.println("SR3:");
// for (int i=0; i < 8; i++){
// Serial.println(SR3[i]);
// }
// Shift out the values: SR1 first, than SR2, finally SR3
valueShiftOut(SR1);
valueShiftOut(SR2);
valueShiftOut(SR3);
// // Magnet
// // LCD shield
// //perform the job by latching the bits from the SR:
digitalWrite(latchPin,HIGH); // send the desired voltage to the SRs
Serial.write(DOING_MOVE);
//digitalWrite(LED,HIGH);
/* In order to make the undo we have to store the previous
move so that we can move the piece back to that position
*/
//prevMove = nextMove; //store the move so that we can revert Don't do this, we won't have done a total trajectory already (only done 1 step)
//back to it
}
// Calculates the trajectory corresponding to the performed chess piece move.
// Inputs is an array where the first 2 values are the rows and columns of the initial position and the next 2 values are the rows and columns of the next position.
// The trajectory is dependent on the type of pion and can be deduced with the following if statements.
int trajectory(int myPositions[4],int arrayTrajectory[]) { // C++ isn't able to return array, therefore the array is globally defined and manipulated inside this function
// begin position
int beginRow=myPositions[0];
int beginColumn=myPositions[1];
// end position
int endRow=myPositions[2];
int endColumn=myPositions[3];
// result:
arrayTrajectory[0]=beginRow;
arrayTrajectory[1]=beginColumn;
//
int arrayTrajectoryLength=(abs(endColumn-beginColumn)+1)*2; // usefull array length. Unusefull part are zeros (length declaration = 16 necessary to global define an array)
// Ex for move column: str(1,5,1,8) ==> array(1,5,1,6,1,7,1,8)==> length(array)=(8-5+1)*2
// Ex for move rows: str(5,1,8,1) ==> array(5,1,6,1,7,1,8,1)==> length(array)=(8-5+1)*2
// Ex for move diagonal: str(1,1,5,5) ==> array(1,1,2,2,3,3,4,4,5,5) ==> length(array)=(5-1+1)*2
// trajectories:
// case 1: go on a straight line (pions:......)
//1.a: move column
if((endRow-beginRow) == 0){ // the row is fixed, so move the columns
if(endColumn>beginColumn){ // move column up: +1
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=8, beginRow,Column already included, 6 more places to fill, fill 2 places each loop, so 3 times in for loop: i= 1,3,5
arrayTrajectory[i+1]=beginRow;// i+1: start at index 2 (the 3th element in array)
arrayTrajectory[i+2]=beginColumn+(i+1)/2; // move column up: +1 every time you go in this for loop
}
}
if(endColumn<beginColumn){ // move column down: -1
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=8, beginRow,Column already included, 6 more places to fill, fill 2 places each loop, so 3 times in for loop: i= 1,3,5
arrayTrajectory[i+1]=beginRow;// i+1: start at index 2 (the 3th element in array)
arrayTrajectory[i+2]=beginColumn-(i+1)/2; // move column down: -1 every time you go in this for loop
}
}
}
//1.b: move row
else if((endColumn-beginColumn) == 0){ // the column is fixed, so move the rows
if(endRow>beginRow){ // move row right: +1
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=8, beginRow,Column already included, 6 more places to fill, fill 2 places each loop, so 3 times in for loop: i= 1,3,5
arrayTrajectory[i+1]=beginRow+(i+1)/2;// i+1: start at index 2 (the 3th element in array), move row up: +1 every time you go in this for loop
arrayTrajectory[i+2]=beginColumn;
}
}
if(endRow<beginRow){ // move row left: -1
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=8, beginRow,Column already included, 6 more places to fill, fill 2 places each loop, so 3 times in for loop: i= 1,3,5
arrayTrajectory[i+1]=beginRow-(i+1)/2;// i+1: start at index 2 (the 3th element in array), move column down: -1 every time you go in this for loop
arrayTrajectory[i+2]=beginColumn;
}
}
}
// case 2: go on a 45° sloped line (pions:......)
else if(abs(endRow-beginRow)==abs(endColumn-beginColumn)){
if((endRow-beginRow)>0){ // if the row has to increase
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=10, beginRow,Column already included, 8 more places to fill, fill 2 places each loop, so 4 times in for loop: i= 1,3,5,7
arrayTrajectory[i+1]=beginRow+(i+1)/2;
}
}
else{ // if the row has to decrease
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=10, beginRow,Column already included, 8 more places to fill, fill 2 places each loop, so 4 times in for loop: i= 1,3,5,7
arrayTrajectory[i+1]=beginRow-(i+1)/2;
}
}
if((endColumn-beginColumn)>0){ // if the column has to increase
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=10, beginRow,Column already included, 8 more places to fill, fill 2 places each loop, so 4 times in for loop: i= 1,3,5,7
arrayTrajectory[i+2]=beginColumn+(i+1)/2;
}
}
else{ // if the column has to decrease
for (int i=1; i<=(arrayTrajectoryLength-2); i=i+2){ // Ex: length(array)=10, beginRow,Column already included, 8 more places to fill, fill 2 places each loop, so 4 times in for loop: i= 1,3,5,7
arrayTrajectory[i+2]=beginColumn-(i+1)/2;
}
}
}
//case 3: (pions: knight)
else{
int arrayTrajectoryLength=8;// you know for sure that the trajectory has 4 positions: 3 in one way, 1 othogonal to it
if(abs(endRow-beginRow)==2) { // move more vertical than horizontal
if(endRow>beginRow){ // move row up for 2 steps, hold for last step. Note that the first step is included in array in the beginning of this function.
arrayTrajectory[2]=beginRow+1; // add 1
arrayTrajectory[4]=beginRow+2; // add 1
arrayTrajectory[6]=beginRow+2; // hold it
}
else{ // move row down for 2 steps, hold for last step. Note that the first step is included in array in the beginning of this function.
arrayTrajectory[2]=beginRow-1; // substract 1
arrayTrajectory[4]=beginRow-2; // substract 1
arrayTrajectory[6]=beginRow-2; // hold it
}
if(endColumn-beginColumn>0){ // move column 1 right
arrayTrajectory[3]=beginColumn; // hold it
arrayTrajectory[5]=beginColumn; // hold it
arrayTrajectory[7]=beginColumn+1; // add 1
}
else{// move column 1 left
arrayTrajectory[3]=beginColumn; // hold it
arrayTrajectory[5]=beginColumn; // hold it
arrayTrajectory[7]=beginColumn-1; // substract 1
}
}
else{ // if(abs(endColumn-beginColumn)==2) { // move more horizontal than vertical
if(endColumn>beginColumn){ // move column up for 2 steps, hold for last step. Note that the first step is included in array in the beginning of this function.
arrayTrajectory[3]=beginColumn+1; // add 1
arrayTrajectory[5]=beginColumn+2; // add 1
arrayTrajectory[7]=beginColumn+2; // hold it
}
else{ // move column down for 2 steps, hold for last step. Note that the first step is included in array in the beginning of this function.
arrayTrajectory[3]=beginColumn-1; // substract 1
arrayTrajectory[5]=beginColumn-2; // substract 1
arrayTrajectory[7]=beginColumn-2; // hold it
}
if(endRow-beginRow>0){ // move row 1 right
arrayTrajectory[2]=beginRow; // hold it
arrayTrajectory[4]=beginRow; // hold it
arrayTrajectory[6]=beginColumn+1; // add 1
}
else{// move row 1 left
arrayTrajectory[2]=beginRow; // hold it
arrayTrajectory[4]=beginRow; // hold it
arrayTrajectory[6]=beginRow-1; // substract 1
}
}
}
return arrayTrajectoryLength;
}
// Function where the input is an array of integer numbers, which correspond to the places where a binary 1 is desired.
// It is an array of numbers corresponding to 1 SR.
// Use this methodes subsequently to shift bits to SR2 and SR3.
// The bits will be shifted with Least Significant Bit (most right bit) First
void valueShiftOut(int myInts[]) {
// Note that since on the Arduino Uno (and other ATMega based boards) an int stores a 16-bit (2-byte) value.
// This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).
// Since there are 24 outputs of the shift registers, it is impossible to shiftout a value of 2^(24-1) at once.
int ARRAY_SIZE=8;//array_size; // array_size has to be declared globally to solve problem (see problem below) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
int valueOut=0;
for (int i=0; i <= ARRAY_SIZE-1; i++){
if(myInts[i]!=0){ // if it are zeros, it are useless array places
//for (int i=0; i <= sizeof(myInts)/sizeof(int); i++){
//int ARRAY_SIZE =sizeof(myInts)/sizeof(int); this doens't work in C code since
//This is tied up in the way C works. Arguments to functions are passed by value. In this case you are passing the address of the array to the function.
//In the function, the argument is seen as a pointer to a character. (there is no int data type.)
//Serial.println(ARRAY_SIZE);
int intTemp=myInts[i];
// if ((intTemp>0) && (intTemp<9)){ // it is SR1 bit
// // do nothing
// }
if ((intTemp>8) && (intTemp<17)){ // it is a SR2 bit
intTemp=intTemp-SR2Offset;
}
else if ((intTemp>16) && (intTemp<25)){ // it is an SR3 bit
intTemp=intTemp-SR3Offset;
}
else {
Serial.println("ERROR: The value of intTemp is not in [1-24]!");
}
int power=1; // neutral element for multiplication*
for (int i=1; i <= intTemp-1; i++){ //2^(intTemp-1) power command not possible in this language
power=power*2;
}
valueOut=valueOut+power; // =valueout to include the previous bit set at 1 (there will probably be more than 1 bit that needs to be HIGH, else you add just zero)
}
}
//return valueOut; // is an integer number (works if void is changed to int)
//Serial.println(valueOut);
digitalWrite(latchPin,LOW); // before shifting bits, put latch low, so previous output is disabled
// After calculating the valueOut which corresponds to the number that the 8 bits represent, the value is shifted in the registers.
shiftOut(dataPin, clockPin, LSBFIRST, valueOut);
// digitalWrite(latchPin,LOW); don't do it here, only latch after sender the 24 bits in 3 steps!
}
=> 
