// V8.1 Adapted for Wokwi - (On Simulide Works, on Wokwi not yet - September 2023
// ***********************************************
// Original Project by Greg06 visit: https://www.instructables.com/Automated-Chessboard/
// This is adapted for Linear Hall Sensor, instead Reed Switch or Unipolar Hall Sensor
//            AUTOMATIC CHESSBOARD
//  To use in SimulIde
// ***********************************************
// Changes from Original
// Pins changed
// Use Arduino Mega (Memory Problems with Nano)
// Use Analog Hall Sensor (Solve White eating Problem)
// Test your own Linear Hall for define the parameters.
// added a Matrix Led 8x8 MAX7219 (For better check the Sensors)
// Added a H-Bridge L298 Added (For PMW the Electromagnet if needed)
// Start Interface Changed
//
// Changes in V8 ¡¡ (Not Finished - Work HvsH - Not Work HvsC after no valid move, no show on LCD not valid move and motors moves white and black like eating) !!
// Case Game Over implemented. Falta!!
// Fixed LCD show No Valid Move on HvsC Game. Falta !! Solo lo muestra en HvsH
// Fixed Motors have to move only on HvsC Black moves. Falta!! mueven luego de Jugada Invalida!! (Repiten ultimo novimiento Negras) 
// White Pieces one Magnet Force N32 (Diam: 6mmx3) - Black Other Magnet Force N52 same size (Diam: 6mmx3)
// B&W with the same Polarization. 
// So diferent Force magnets made diferent outputs from Hall Sensor
// Keep the same polarization for B&W avoid electromagnet problems
// Change polarization of the Electromagnet not work proprertly, so is better to keep same polarization for all pieces
// Sensors only works when the Player Turn's end. (Previous versions works all time)
// Record Sensors Positions only if Move is Valid (Previous versions change the position when Invalid move was made, and game can't continue)
//
//
// Detected Limitations
// Promotion: Only to Queen, other pieces not implemented yet 
// En passant eating, not implemented yet (Code need to recognize three sensor´s magnet changes)
//
// ******************************  INCLUDING FILES
#include "global_V3.h"  // SPK Adapted for Linear MUX and new devices
#include "Micro_Max.h"
#include <Wire.h>
#include "LedControl.h" // Added for Matrix Led based on MAX7219
 #include <LiquidCrystal_I2C.h>                   // put this line comment if you are on Simulide
 LiquidCrystal_I2C lcd(0x27,16,2);                // put this line comment if you are on Simulide // In Skolodi Case LCD is on 0x27 and not in 0x20
// #include <LiquidCrystal_AIP31068_I2C.h>        // erase this line comment if you are on Simulide
// LiquidCrystal_AIP31068_I2C lcd( 0x3E, 16, 2 ); // erase this line comment if you are on Simulide // 3E Changed for Simulide simulation
LedControl lc=LedControl(51,52,53,1); // For A Mega DIN=51 , CLK=52, CS=53, 1 Matrix Led

// ****************************************  SETUP
void setup() {
  Serial.begin(9600);

  //  Electromagnet H-Bridge V7
  	pinMode(IN1, OUTPUT);
  	pinMode(IN2, OUTPUT);	
	pinMode (MAGNET, OUTPUT);

// Matrix Led V7
	lc.shutdown(0,false);		// Turn on matriz Led
 	lc.setIntensity(0,4);		// Set Intensity of Led
 	lc.clearDisplay(0);			// Turn off leds

  //  Motor
  pinMode (MOTOR_WHITE_STEP, OUTPUT);
  pinMode (MOTOR_WHITE_DIR, OUTPUT);
  pinMode (MOTOR_BLACK_STEP, OUTPUT);
  pinMode (MOTOR_BLACK_DIR, OUTPUT);

  //  Multiplexer  
  // Option for reduce MUX from 4 to 2 analized, but lattence appears and a lot of Diodes needed, so decided Mantain 4 MUX
  for (byte i = 0; i < 4; i++) {
    pinMode (MUX_ADDR [i], OUTPUT);
    digitalWrite(MUX_ADDR [i], LOW);
    pinMode (MUX_SELECT [i], OUTPUT);
    digitalWrite(MUX_SELECT [i], HIGH);
  }
  pinMode (MUX_OUTPUT, INPUT_PULLUP);

  //  Set the sensors status V7
Serial.println("  Set Sensors Status V7");
Serial.println("  +-----------------+");
  for (byte i = 0; i < 2; i++) {
    Serial.print(' ');
    Serial.print(8 - i);
    Serial.print("| ");
    for (byte j = 0; j < 8; j++) {
      reed_sensor_status[7-i][j] = -1;  
      reed_sensor_status_memory[7-i][j] = -1;
      Serial.print(reed_sensor_status[7-i][j]);
      Serial.print(' ');  
    }
    Serial.println('|');
  }
  for (byte i = 2; i < 6; i++) {
    Serial.print(' ');
    Serial.print(8 - i);
    Serial.print("| ");
    for (byte j = 0; j < 8; j++) {
      reed_sensor_status[7-i][j] = 0;  
      reed_sensor_status_memory[7-i][j] = 0;
      Serial.print(reed_sensor_status[7-i][j]);
      Serial.print(' ');    
    }
     Serial.println('|');
  }
for (byte i = 6; i < 8; i++) {
  Serial.print(' ');
    Serial.print(8 - i);
    Serial.print("| ");
    for (byte j = 0; j < 8; j++) {
      reed_sensor_status[7-i][j] = 1;  
      reed_sensor_status_memory[7-i][j] = 1;
      Serial.print(reed_sensor_status[7-i][j]);
      Serial.print(' ');    
    }
     Serial.println('|');
  }
  Serial.println("  +-----------------+");
  Serial.println("   a b c d e f g h");
  //  MicroMax
  lastH[0] = 0;

  //  LCD
  lcd.init();

  //  Countdown
  timer = millis();

  //  Arcade button - Limit Switch
  pinMode (BUTTON_WHITE_SWITCH_MOTOR_WHITE, INPUT_PULLUP); 
  pinMode (BUTTON_BLACK_SWITCH_MOTOR_BLACK, INPUT_PULLUP); 
  lcd_display();

 }

// *****************************************  LOOP
void loop() 
{
  switch (sequence) 
  {
    case start:
      lcd_display();
      if (button(WHITE) == true) 
        {                                       // White=Down Button , Black Enter Button.
          MenuItemSelected=MenuItemSelected+2;
          if (MenuItemSelected>3) 
            {
            MenuItemSelected=0;
            }
  	   // game_mode = HvsH;
       lcd_display();
        }
      else if (button(BLACK) == true) 
        {                                       // Button Black is Enter
        switch (MenuItemSelected) 
          {
          case 0:
           game_mode=HvsH;
           initial_record_sensors(); // SPK V7
		        sequence= player_white;
            break;

           case 2:
           game_mode = HvsC;
           sequence = calibration;
		        initial_record_sensors(); // SPK V7
            break;
          }
	       }
    break;                            // break Case Start

    case calibration:
      lcd_display();
      calibrate();
      sequence = player_white;
      break;

    case player_white:
      if (millis() - timer > 995)   // When 1 second passed
      {                             
        countdown();                // Rest 1 second. If New Turn, save time and change turn
        lcd_display();              // Show the time
      }
      //detect_human_movement();    // V7 SPK Move down for check sensors only when the button is press
      if (button(WHITE) == true) 
      {                             // White player end turn
        detect_human_movement();    // V7 SPK move here - Check the sensors
		    player_displacement();      // Save and convert on coordinates the previous move and the last move
        if (game_mode == HvsH) 
        {
          AI_HvsH();                // Chekc is movement is valid
          if (no_valid_move == false) 
          {
		        record_sensors();       // SPK V7
		        new_turn_countdown = true;  // V8.1 Set the New turn, works when countdown is called
            sequence = player_black;
            break;                  // V8.1 go out of the sequence to start case Player Black
		      }
          else if (no_valid_move == true) // V8.1 change else for esle if
		      {				 		              // V8
		      serialBoard();            // V8.1 Show Serial Board
          lcd_display();            // Show No Valid Move, change state of No Valid Move and return
		      break;  	                // V8.1 Have to break to start Player White case again
		      }						              // V8
        }
        else if (game_mode == HvsC) 
        {
          AI_HvsC();                // Chekc is movement is valid
          if (no_valid_move == false) 
          {  	                      // V8
		      record_sensors(); 		    // V8
		      new_turn_countdown = true;  // V8.1 Set the New turn, works when countdown is called
          sequence = player_black;	// V8
		      break;                    // V8.1 go out of the sequence to start case Player Black
          }
		      else if (no_valid_move == true) // V8.1 change else for esle if
		      {						             // V8.1
      		serialBoard();            // V8.1 Show Serial Board
          lcd_display();       		 // V8
      		sequence = player_white; // V8.1
      		break;                   // V8.1 go out of the sequence to start case Player White
          }						             // V8.1
        }
      }                            // V8.1 close Button White
      break;                       // break case Player White

      case player_black:
        if (millis() - timer > 995)  // V8.1 clock for Computer Showed. 
        {                             
        countdown();                // Rest 1 second. If New Turn, save time and change turn
        lcd_display();              // Show the time
        }
        //  Game mode HvsH
        if (game_mode == HvsH) 
        {                          
          if (millis() - timer > 995) // When 1 second passed
          {                             
          countdown();                // Rest 1 second. If New Turn, save time and change turn
          lcd_display();              // Show the time
          }
          if (button(BLACK) == true) 
          {                           // Black human player end turn
            detect_human_movement();  // V7 moved here - detect sensors
		        player_displacement();    // Save and convert on coordinates the previous move and the last move
            AI_HvsH();                // Chekc is movement is valid
            if (no_valid_move == false) 
            {
      			record_sensors();         // SPK V7
      			new_turn_countdown = true;// V8.1 moved. Set the New turn, works when countdown is called
            sequence = player_white;
            break;                   // V8.1 go out of the sequence to start case Player White
      			}
            else if (no_valid_move == true) // V8.1 change else for esle if
            {
              lcd_display();
              sequence = player_black;//V8.1
              break;                  // V8.1 go out of the sequence to start again case Player black
            }
          }
        }                           // Close HvsH mode
        //  Game mode HvsC
        else if (game_mode == HvsC) 
        {
          black_player_movement();  //  Move the black chess piece
          record_sensors();         // SPK V7
		      new_turn_countdown = true;// V8.1 moved. Set the New turn, works when countdown is called
          sequence = player_white;
          break;                   // V8.1 go out of the sequence to start case Player White
        }
        break;                      // break player_black case

      // } // V8.1 moved up // Close "if (button(WHITE)" on Case Player_white If } moved up, (was here on Original Greg06 code) 

      case game_over:             // V8.1 added the Game Over case
      lcd_display();
      for (;;);                   // V8.1 infinite For, to collapse Arduino and have to restart when Game Over (Same as on Micromax)
      break; 
  } // Close Swich sequence
} // close Loop

// ***************************************  SWITCH
boolean button(byte type) {

  if (type == WHITE && digitalRead(BUTTON_WHITE_SWITCH_MOTOR_WHITE) != HIGH) {
    delay(250);
    return true;
  }
  if (type == BLACK && digitalRead(BUTTON_BLACK_SWITCH_MOTOR_BLACK) != HIGH) {
    delay(250);
    return true;
  }
  return false;
}

// ************************************  CALIBRATE
void calibrate() {

  //  Slow displacements up to touch the limit switches
  while (digitalRead(BUTTON_WHITE_SWITCH_MOTOR_WHITE) == HIGH) motor(B_T, SPEED_SLOW, calibrate_speed);
  while (digitalRead(BUTTON_BLACK_SWITCH_MOTOR_BLACK) == HIGH) motor(L_R, SPEED_SLOW, calibrate_speed);
  delay(500);

  //  Rapid displacements up to the Black start position (e7)
  motor(R_L, SPEED_FAST, TROLLEY_START_POSITION_X);
  motor(T_B, SPEED_FAST, TROLLEY_START_POSITION_Y);
  delay(500);
}

// ****************************************  MOTOR
void motor(byte direction, int speed, float distance) 
{

  float step_number = 0;

  //  Calcul the distance
  if (distance == calibrate_speed) step_number = 4;
  else if (direction == LR_BT || direction == RL_TB || direction == LR_TB || direction == RL_BT) step_number = distance * SQUARE_SIZE * 1.44; //  Add an extra length for the diagonal
  else step_number = distance * SQUARE_SIZE;

  //  Direction of the motor rotation
  if (direction == R_L || direction == T_B || direction == RL_TB) digitalWrite(MOTOR_WHITE_DIR, HIGH);
  else digitalWrite(MOTOR_WHITE_DIR, LOW);
  if (direction == B_T || direction == R_L || direction == RL_BT) digitalWrite(MOTOR_BLACK_DIR, HIGH);
  else digitalWrite(MOTOR_BLACK_DIR, LOW);

  //  Active the motors
  for (int x = 0; x < step_number; x++) 
  {
    if (direction == LR_TB || direction == RL_BT) digitalWrite(MOTOR_WHITE_STEP, LOW);
    else digitalWrite(MOTOR_WHITE_STEP, HIGH);
    if (direction == LR_BT || direction == RL_TB) digitalWrite(MOTOR_BLACK_STEP, LOW);
    else digitalWrite(MOTOR_BLACK_STEP, HIGH);
    delayMicroseconds(speed);
    digitalWrite(MOTOR_WHITE_STEP, LOW);   // SPK In Simulide after Calibrate this matain HIGH, but actualy the motor doesn't move
    digitalWrite(MOTOR_BLACK_STEP, LOW);
    delayMicroseconds(speed);
  }
}

// *******************************  ELECTROMAGNET H-Bridge
void electromagnet(boolean state) 
{
  if (state == true)  
	{
    	analogWrite(MAGNET, 200);		// V8 PWM Electromagnet
	delay(600);
	}
	else  
		{
    delay(600);
    digitalWrite(MAGNET, LOW);
		}
}
// ***********************************  COUNTDONW
void countdown() 
{

  //  Set the time of the current player
  if (new_turn_countdown == true ) 
    {
      new_turn_countdown = false;
      if (sequence == player_white) 
      {
        second = second_white;
        minute = minute_white;
        if (minute_white == 0 && second_white == 0)
        {                                           // V8.1 - When Player time is 0 -> Game Over sequence
        black_win = true;
        sequence = game_over;
        return;
        }
      }
      else if (sequence == player_black) 
        {
        second = second_black;
        minute = minute_black;
        if (minute_black == 0 && second_black == 0)
          {                                         // V8.1 - When Player time is 0 -> Game Over sequence
          white_win = true;
          sequence = game_over;
          return;
          }
        }
    }

  //  Countdown
  timer = millis();
  second = second - 1;
  if (second < 1) 
    {
      second = 60;
      minute = minute - 1;
    }

  //  Record the white player time
  if (sequence == player_white) 
    {
      second_white = second;
      minute_white = minute;
    }
  //  Record the black player time
  else if (sequence == player_black) 
    {
      second_black = second;
      minute_black = minute;
    }
}                                 // Close countdown()

// ***********************  BLACK PLAYER MOVEMENT
void black_player_movement() 
{

  //  Convert the AI characters in variables
  int departure_coord_X = lastM[0] - 'a' + 1;
  int departure_coord_Y = lastM[1] - '0';
  int arrival_coord_X = lastM[2] - 'a' + 1;
  int arrival_coord_Y = lastM[3] - '0';
  byte displacement_X = 0;
  byte displacement_Y = 0;

  //  Trolley displacement to the starting position
  int convert_table [] = {0, 7, 6, 5, 4, 3, 2, 1, 0};
  byte white_capturing = 1;
  if (abs(reed_sensor_status_memory[convert_table[arrival_coord_Y]][arrival_coord_X - 1]) == 1) white_capturing = 0;
// square with wite = 1
// square with black = -1
// square with no piecw = 0
  for (byte i = abs(white_capturing); i < 2; i++) 
  {
    if (i == 0) 
    {
      displacement_X = abs(arrival_coord_X - trolley_coordinate_X);
      displacement_Y = abs(arrival_coord_Y - trolley_coordinate_Y);
	    digitalWrite(IN1, LOW);	// SPK V7 Check the best Electromagnet polarization for set this
  	  digitalWrite(IN2, HIGH);	// SPK
	    Serial.println("Piece White moving");// for debug
    }
    else if (i == 1) 
    {
      displacement_X = abs(departure_coord_X - trolley_coordinate_X);
      displacement_Y = abs(departure_coord_Y - trolley_coordinate_Y);
	    digitalWrite(IN1, LOW);	// SPK V7 Same Polarization 
  	  digitalWrite(IN2, HIGH);	// SPK V7
	   Serial.println("Piece Black moving");// SPK for debug
    }
    if (departure_coord_X > trolley_coordinate_X) motor(T_B, SPEED_FAST, displacement_X);
    else if (departure_coord_X < trolley_coordinate_X) motor(B_T, SPEED_FAST, displacement_X);
    if (departure_coord_Y > trolley_coordinate_Y) motor(L_R, SPEED_FAST, displacement_Y);
    else if (departure_coord_Y < trolley_coordinate_Y) motor(R_L, SPEED_FAST, displacement_Y);
    if (i == 0) 
    {
      electromagnet(true);
      motor(R_L, SPEED_SLOW, 0.5);
      motor(B_T, SPEED_SLOW, arrival_coord_X - 0.5);
      electromagnet(false);
      motor(L_R, SPEED_FAST, 0.5);
      motor(T_B, SPEED_FAST, arrival_coord_X - 0.5);
      trolley_coordinate_X = arrival_coord_X;
      trolley_coordinate_Y = arrival_coord_Y;
    }
  }
  trolley_coordinate_X = arrival_coord_X;
  trolley_coordinate_Y = arrival_coord_Y;

  //  Move the Black chess piece to the arrival position
  displacement_X = abs(arrival_coord_X - departure_coord_X);
  displacement_Y = abs(arrival_coord_Y - departure_coord_Y);

  electromagnet(true);
  //  Bishop displacement
  if (displacement_X == 1 && displacement_Y == 2 || displacement_X == 2 && displacement_Y == 1) 
  {
    if (displacement_Y == 2) 
    {
      if (departure_coord_X < arrival_coord_X) 
      {
        motor(T_B, SPEED_SLOW, displacement_X * 0.5);
        if (departure_coord_Y < arrival_coord_Y) motor(L_R, SPEED_SLOW, displacement_Y);
        else motor(R_L, SPEED_SLOW, displacement_Y);
        motor(T_B, SPEED_SLOW, displacement_X * 0.5);
      }
      else if (departure_coord_X > arrival_coord_X) 
      {
        motor(B_T, SPEED_SLOW, displacement_X * 0.5);
        if (departure_coord_Y < arrival_coord_Y) motor(L_R, SPEED_SLOW, displacement_Y);
        else motor(R_L, SPEED_SLOW, displacement_Y);
        motor(B_T, SPEED_SLOW, displacement_X * 0.5);
      }
    }
    else if (displacement_X == 2) 
    {
      if (departure_coord_Y < arrival_coord_Y) 
      {
        motor(L_R, SPEED_SLOW, displacement_Y * 0.5);
        if (departure_coord_X < arrival_coord_X) motor(T_B, SPEED_SLOW, displacement_X);
        else motor(B_T, SPEED_SLOW, displacement_X);
        motor(L_R, SPEED_SLOW, displacement_Y * 0.5);
      }
      else if (departure_coord_Y > arrival_coord_Y) 
      {
        motor(R_L, SPEED_SLOW, displacement_Y * 0.5);
        if (departure_coord_X < arrival_coord_X) motor(T_B, SPEED_SLOW, displacement_X);
        else motor(B_T, SPEED_SLOW, displacement_X);
        motor(R_L, SPEED_SLOW, displacement_Y * 0.5);
      }
    }
  }
  //  Diagonal displacement
    else if (displacement_X == displacement_Y) 
    {
      if (departure_coord_X > arrival_coord_X && departure_coord_Y > arrival_coord_Y) motor(RL_BT, SPEED_SLOW, displacement_X);
      else if (departure_coord_X > arrival_coord_X && departure_coord_Y < arrival_coord_Y) motor(LR_BT, SPEED_SLOW, displacement_X);
      else if (departure_coord_X < arrival_coord_X && departure_coord_Y > arrival_coord_Y) motor(RL_TB, SPEED_SLOW, displacement_X);
      else if (departure_coord_X < arrival_coord_X && departure_coord_Y < arrival_coord_Y) motor(LR_TB, SPEED_SLOW, displacement_X);
    }
  //  Kingside castling
  else if (departure_coord_X == 5 && departure_coord_Y == 8 && arrival_coord_X == 7 && arrival_coord_Y == 8) 
  {                               //  Kingside castling
    motor(R_L, SPEED_SLOW, 0.5);
    motor(T_B, SPEED_SLOW, 2);
    electromagnet(false);
    motor(T_B, SPEED_FAST, 1);
    motor(L_R, SPEED_FAST, 0.5);
    electromagnet(true);
    motor(B_T, SPEED_SLOW, 2);
    electromagnet(false);
    motor(T_B, SPEED_FAST, 1);
    motor(R_L, SPEED_FAST, 0.5);
    electromagnet(true);
    motor(L_R, SPEED_SLOW, 0.5);
  }
  else if (departure_coord_X == 5 && departure_coord_Y == 8 && arrival_coord_X == 3 && arrival_coord_Y == 8) 
  {                             //  Queenside castling
    motor(R_L, SPEED_SLOW, 0.5);
    motor(B_T, SPEED_SLOW, 2);
    electromagnet(false);
    motor(B_T, SPEED_FAST, 2);
    motor(L_R, SPEED_FAST, 0.5);
    electromagnet(true);
    motor(T_B, SPEED_SLOW, 3);
    electromagnet(false);
    motor(B_T, SPEED_FAST, 1);
    motor(R_L, SPEED_FAST, 0.5);
    electromagnet(true);
    motor(L_R, SPEED_SLOW, 0.5);
  }
  //  Horizontal displacement
  else if (displacement_Y == 0) 
    {
      if (departure_coord_X > arrival_coord_X) motor(B_T, SPEED_SLOW, displacement_X);
      else if (departure_coord_X < arrival_coord_X) motor(T_B, SPEED_SLOW, displacement_X);
    }
  //  Vertical displacement
  else if (displacement_X == 0) 
    {
      if (departure_coord_Y > arrival_coord_Y) motor(R_L, SPEED_SLOW, displacement_Y);
      else if (departure_coord_Y < arrival_coord_Y) motor(L_R, SPEED_SLOW, displacement_Y);
    }
  electromagnet(false);

  //  Upadte the reed sensors states with the Balck move
  reed_sensor_status_memory[convert_table[departure_coord_Y]][departure_coord_X - 1] = 1;
  reed_sensor_status_memory[convert_table[arrival_coord_Y]][arrival_coord_X - 1] = 0;
  reed_sensor_status[convert_table[departure_coord_Y]][departure_coord_X - 1] = 1;
  reed_sensor_status[convert_table[arrival_coord_Y]][arrival_coord_X - 1] = 0;

}             // close black_player_movement


// **********************************  LCD DISPLAY
void lcd_display() 
{

  lcd.backlight();  // put this line comment if you are on Simulide

  if (no_valid_move == true) 
  {
    lcd.setCursor(0, 0);
    lcd.print("  NO VALID MOVE  ");
    lcd.setCursor(0, 1);
    lcd.print("                ");
    delay(2000);
    no_valid_move = false;            // V8.1 need to be adapted // HvsH with this line -> work. // HvsC with this line -> not work
    return;                           // V8.1 not sure if return go to the same line previous lcd_display() was called, or other place
  }

  switch (sequence) 
  {
    case start_up:
      lcd.setCursor(0, 0);
      lcd.print("   AUTOMATIC    ");
      lcd.setCursor(0, 1);
      lcd.print("   CHESSBOARD   ");
      sequence = start;
      delay(4000);
      break;                        // V8.1
    case start:
      lcd.setCursor(0, 0);
      //lcd.print(" PRESS A - HvsH ");
      lcd.print(MenuItems[MenuItemSelected]); // V7 Change
	    lcd.setCursor(0, 1);
      // lcd.print(" PRESS B - HvsC ");
      lcd.print(MenuItems[MenuItemSelected+1]); // V7 Change
	    break;                       // V8.1
    case calibration:
      lcd.setCursor(0, 0);
      lcd.print("  CALIBRATION   ");
      lcd.setCursor(0, 1);
      lcd.print("                ");
      break;
    case player_white:
      lcd.setCursor(0, 0);
      lcd.print("     WHITE      ");
      lcd.setCursor(0, 1);
      lcd.print("     " + String(minute) + " : " + String(second) + "     ");
      break;
    case player_black:
      lcd.setCursor(0, 0);
      lcd.print("     BLACK      ");
      lcd.setCursor(0, 1);
      lcd.print("     " + String(minute) + " : " + String(second) + "     ");
      break;
    case game_over:             // V8.1 added the Game Over case for timelapse. For other Issues is set on Micro Max
      if (white_win == true)              // V8.1 Not work. Counter go to 256
        {
          lcd.setCursor(0, 0);
          lcd.print("     WHITE      ");
          lcd.setCursor(0, 1);
          lcd.print("      WINS      ");
        }
        else if (black_win == true)         // V8.1 Not work. Counter go to 256
        {
            lcd.setCursor(0, 0);
            lcd.print("     BLACK      ");
            lcd.setCursor(0, 1);
            lcd.print("      WINS      ");
        }
    break;                              // V8.1                       
 }                                     // close sequence
}                                      // close lcd display 

// ************************  DETECT HUMAN MOVEMENT  V7 change to run this part only after press the button
void detect_human_movement() 
{

  //  Record the reed switches status
 
  byte column = 6;
  byte row = 0;

  for (byte i = 0; i < 4; i++) 
  {
    digitalWrite(MUX_SELECT[i], LOW);
    for (byte j = 0; j < 16; j++) 
    {
      for (byte k = 0; k < 4; k++) 
	     {
        digitalWrite(MUX_ADDR [k], MUX_CHANNEL [j][k]);
	      delay(5); 						// SPK Added for Recomendation on Questions See shuttle123
        int hallMeasure = analogRead(MUX_OUTPUT); // SPK TEST your own linear hall to set this parameters
		    if (hallMeasure > 540 && hallMeasure <= 740) 
        { // 540 & 740 for Simulide Set the Value manualy after test
          reed_sensor_record[column][row] = 1;
		      //hall_value[column][row]=hallMeasure; // SPK Added for take the Hall measure
       	}
        else if (hallMeasure > 840 && hallMeasure <= 1100) 
        { 
          // 840 & 1100 for Simulide, Set the Value manualy after test
          reed_sensor_record[column][row] = -1;
  		    //hall_value[column][row]=hallMeasure; // SPK Added for take the Hall measure
       	}
        else 
        { // Any other Value means no piece. Set the Value manualy after test
          reed_sensor_record[column][row] = 0;
		      //hall_value[column][row]=hallMeasure; // SPK Added for take the Hall measure
      	}
	     }
	
     // reed_sensor_record[column][row] = digitalRead(MUX_OUTPUT);
      row++;
      if (j == 7) 
      {
        column++;
        row = 0;
      }
    }
    for (byte l = 0; l < 4; l++) 
    {
      digitalWrite(MUX_SELECT[l], HIGH);
    }
    if (i == 0) column = 4;
    if (i == 1) column = 2;
    if (i == 2) column = 0;
    row = 0;
  }
  Serial.println("  Detect Human Movement");
  Serial.println("  +-----------------+");
  for (byte i = 0; i < 8; i++) 
  {
    Serial.print(' ');
    Serial.print(8 - i);
    Serial.print("| ");
    for (byte j = 0; j < 8; j++) 
    {
      Serial.print(reed_sensor_record[7-i][j]);
      Serial.print(' ');
    reed_sensor_status_memory[7 - i][j] = reed_sensor_record[i][j];
    }
    Serial.println('|');
  }
  Serial.println("  +-----------------+");
  Serial.println("   a b c d e f g h");

  //  Compare the old and new status of the reed switches

  for (byte i = 0; i < 8; i++) 
  {
    for (byte j = 0; j < 8; j++) 
    {
      if (reed_sensor_status[i][j] != reed_sensor_status_memory[i][j]) 
      {
        if (reed_sensor_status_memory[i][j] == 0) // SPK adapted for Linear Hall
	       {
          reed_colone[0] = i; 
          reed_line[0] = j;  
         }
        if (reed_sensor_status_memory[i][j] == 1) // 1=White SPK adapted for Linear Hall
	       {
          reed_colone[1] = i; 
          reed_line[1] = j; 
         }
		    if (reed_sensor_status_memory[i][j] == -1) // -1=Black SPK adapted for Linear Hall
	       {
          reed_colone[1] = i; 
          reed_line[1] = j; 
          }
      }
    }
  }
 //  Set the new status of the reed sensors
 // record_sensors(); // V7 moved to record_sensors()
 
}                 // close detect_human_movement


// **************************  RECORD SENSORS V7
void record_sensors() 
{
 lc.clearDisplay(0);			// blanquea matriz Led
   for (byte i = 0; i < 8; i++) 
   {
    	for (byte j = 0; j < 8; j++) 
      {
      reed_sensor_status[i][j] = reed_sensor_status_memory[i][j];
	    if(reed_sensor_status[i][j] ==1 || reed_sensor_status[i][j] ==-1) 
        {
	       lc.setLed(0,i,j,true); // Turn on Led where is a piece on
	      }
      }
    }
}
// **************************  INITIAL RECORD SENSORS V7
void initial_record_sensors()
{
lc.clearDisplay(0);			// blanquea matriz Led
detect_human_movement();
for (byte i = 0; i < 8; i++) 
  {
    for (byte j = 0; j < 8; j++) 
    {
      if(reed_sensor_status[i][j] ==1 || reed_sensor_status[i][j] ==-1) 
      {
    	 lc.setLed(0,i,j,true); // Turn on Led where is a piece on
    	}
  	}
  }
}
// **************************  PLAYER DISPLACEMENT
void player_displacement() 
{

  //  Convert the reed sensors switches coordinates in characters
  char table1[] = {'8', '7', '6', '5', '4', '3', '2', '1'};
  char table2[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'};

  mov[0] = table2[reed_line[0]];  // For move e2 -> e4
 // Serial.print("mov[0]");  // added SPK for debug
 // Serial.println(mov[0]);    // added SPK for debug - Show letter e
  mov[1] = table1[reed_colone[0]];
// Serial.print("mov[1]");    // added SPK for debug
// Serial.println(mov[1]);    // added SPK for debug - Show number 2 (e2, previous move)
  mov[2] = table2[reed_line[1]];
// Serial.print("mov[2]");    // added SPK for debug
// Serial.println(mov[2]);    // added SPK for debug - Show letter e
  mov[3] = table1[reed_colone[1]];
// Serial.print("mov[3]");    // added SPK for debug
// Serial.println(mov[3]);    // added SPK for debug  - Show number 4 (e4, last move)
}