//BIBLIOTECAS INCLUIDAS
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <Stepper.h>

//Sensores & Pinagem
const int sensor_1 = 16; //Pino  - 1 ANDAR
const int sensor_2 = ; //Pino  - 2 ANDAR
const int sensor_3 = ; //Pino  - 3 ANDAR
const int sensor_4 = ; //Pino  - 4 ANDAR
const int sensor_5 = ; //Pino  - 5 ANDAR
const int sensor_6 = ; //Pino  - 6 ANDAR
const int sensor_7 = ; //Pino  - 7 ANDAR
const int sensor_8 = ; //Pino  - 8 ANDAR
const int sensor_9 = ; //Pino  - 9 ANDAR
const int sensor_1_PC = ; //Pino  - 1 ANDAR PEÇA
const int sensor_2_PC = ; //Pino  - 2 ANDAR PEÇA
const int sensor_3_PC = ; //Pino  - 3 ANDAR PEÇA
const int sensor_4_PC = ; //Pino  - 4 ANDAR PEÇA
const int sensor_5_PC = ; //Pino  - 5 ANDAR PEÇA
const int sensor_6_PC = ; //Pino  - 6 ANDAR PEÇA
const int sensor_7_PC = ; //Pino  - 7 ANDAR PEÇA
const int sensor_8_PC = ; //Pino  - 8 ANDAR PEÇA
const int sensor_9_PC = ; //Pino  - 9 ANDAR PEÇA

//Drivers & Motores
const int stepPin_X = A0;
const int dirPin_X = A1;
const int stepPin_Y = A6;
const int dirPin_Y = A7;
const int stepPin_Z = 46;
const int dirPin_Z = 48;

//Declarações de String para Depósito
const String Deposito_1 = "1D";
const String Deposito_2 = "2D";
const String Deposito_3 = "3D";
const String Deposito_4 = "4D";
const String Deposito_5 = "5D";
const String Deposito_6 = "6D";
const String Deposito_7 = "7D";
const String Deposito_8 = "8D";
const String Deposito_9 = "9D";
const String Deposito_10 = "10D";
const String Deposito_11 = "11D";
const String Deposito_12 = "12D";

//Declarações de String para Retirar
const String Retirada_1 = "1A";
const String Retirada_2 = "2A";
const String Retirada_3 = "3A";
const String Retirada_4 = "4A";
const String Retirada_5 = "5A";
const String Retirada_6 = "6A";
const String Retirada_7 = "7A";
const String Retirada_8 = "8A";
const String Retirada_9 = "9A";
const String Retirada_10 = "10A";
const String Retirada_11 = "11A";
const String Retirada_12 = "12A";

//Modo Automático
const String Modo_Auto = "A0";

//Validação da informação recebida
String Informacao = "";

//Teclado Matricial
const byte linhas = 4; //número de linhas do teclado
const byte colunas = 4; //número de colunas do teclado 

char SIMBOLOS [linhas][colunas] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}//'*' = CLEAR ; '#' = ENTER
}; 

byte PINOS_LINHAS[linhas] = {40,42,44,49};
byte PINOS_COLUNAS[colunas] = {50,51,52,53};

Keypad customKeypad = Keypad( makeKeymap(SIMBOLOS), 
PINOS_LINHAS, PINOS_COLUNAS, linhas, colunas);

//Display LCD I2C
LiquidCrystal_I2C lcd(0x27, 16, 2);

/*DECLARAÇÃO DE ENTRADAS (SENSORES), DECLARAÇÃO DE SAÍDAS (DRIVERS MOTORES),
INICIALIZAÇÃO DO DISPLAY E COMUNICAÇÃO SERIAL (BAUDRATE = 9600)
*/
void setup()
{
  pinMode(sensor_1, INPUT_PULLUP);
  pinMode(sensor_2, INPUT_PULLUP);
  pinMode(sensor_3, INPUT_PULLUP);
  pinMode(sensor_4, INPUT_PULLUP);
  pinMode(sensor_5, INPUT_PULLUP);
  pinMode(sensor_6, INPUT_PULLUP);
  pinMode(sensor_7, INPUT_PULLUP);
  pinMode(sensor_8, INPUT_PULLUP);
  pinMode(sensor_9, INPUT_PULLUP);
  pinMode(sensor_10, INPUT_PULLUP);
  pinMode(sensor_11, INPUT_PULLUP);
  pinMode(sensor_12, INPUT_PULLUP);
  pinMode(sensor_1_PC, INPUT_PULLUP);
  pinMode(sensor_2_PC, INPUT_PULLUP);
  pinMode(sensor_3_PC, INPUT_PULLUP);
  pinMode(sensor_4_PC, INPUT_PULLUP);
  pinMode(sensor_5_PC, INPUT_PULLUP);
  pinMode(sensor_6_PC, INPUT_PULLUP);
  pinMode(sensor_7_PC, INPUT_PULLUP);
  pinMode(sensor_8_PC, INPUT_PULLUP);
  pinMode(sensor_9_PC, INPUT_PULLUP);
  pinMode(sensor_10_PC, INPUT_PULLUP);
  pinMode(sensor_11_PC, INPUT_PULLUP);
  pinMode(sensor_12_PC, INPUT_PULLUP);
  pinMode(stepPin_X, OUTPUT);
  pinMode(stepPin_Y, OUTPUT);
  pinMode(stepPin_Z, OUTPUT);
  pinMode(dirPin_X, OUTPUT);
  pinMode(dirPin_Y, OUTPUT);
  pinMode(dirPin_Z, OUTPUT);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(2,0);
  lcd.print("INICIALIZACAO");
  delay(1000);
  lcd.clear();
  Serial.begin(9600);
  lcd.setCursor(0,0);
  lcd.print("Instrucoes dadas");
  lcd.setCursor(2,1);
  lcd.print("pela serial");
  delay(2000);
  serial();
}
//INSTRUÇÕES DO MODO DE FUNCIONAMENTO
void serial()
{
  Serial.println("INSTRUÇÕES:");
  delay(500);
  Serial.println("funcionamento manual:");
  delay(500);
  Serial.println("");
  Serial.println("MODO DEPOSITO:");
  delay(500);
  Serial.println("Ao colocar o produto 'pallet' na cabine,");
  delay(500);
  Serial.println("Selecione um andar, esse andar será onde o produto");
  delay(500);
  Serial.println("Ficará armazenado, junto ao andar");
  delay(500);
  Serial.println("Selecione a letra 'D' no teclado, isso ativará o modo deposito,");
  delay(500);
  Serial.println("Por fim pressione '#' para confirmar sua ação.");
  delay(500);
  Serial.println("");
  Serial.println("MODO RETIRAR:");
  delay(500);
  Serial.println("No modo retirar selecione o andar onde deseja");
  delay(500);
  Serial.println("Fazer a retirada do produto 'pallet', junto");
  delay(500);
  Serial.println("Ao andar selecione a letra  'A', por fim");
  delay(500);
  Serial.println("Pressione '#' para confirmar a ação.");
  delay(500);
  Serial.println("");
  Serial.println("Modo Automático:");
  delay(500);
  Serial.println("No modo automático, você não tem o 'controle'");
  delay(500);
  Serial.println("O elevador irá em uma sequência automática para os andares vazios e efetuar o deposito");
  delay(500);
  Serial.println("Em caso de retirada será da mesma forma, automática.");
  delay(500);
  Serial.println("Modo de acionamento desse modo é 'A0' e para confirmar a ação o '#'");
  delay(500);
  inicio();
}
//INICIO PADRAO (AGUARDANDO AÇÃO)
void inicio() 
{
  lcd.clear();
  lcd.setCursor(2,0);
  lcd.print("Acao:");
}
//OPÇÃO INVÁLIDA DE ANDAR OCUPADO 
void ocupado()
{
  lcd.clear();
  lcd.setCursor(6,0);
  lcd.print("Andar");
  lcd.setCursor(5,1);
  lcd.print("Ocupado");
  delay(2000);
  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("Tente novamente");
  delay(1000);
  inicio();
}

//OPÇÃO INVÁLIDA DE ANDAR OCUPADO 
void vazio()
{
  lcd.clear();
  lcd.setCursor(6,0);
  lcd.print("Andar");
  lcd.setCursor(6,1);
  lcd.print("Vazio");
  delay(2000);
  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("Tente novamente");
  delay(1000);
  inicio();
}

void loop()
{
char customKey = customKeypad.getKey();

  if (customKey){
    switch (customKey)
    {
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
      case '0':
      case 'A':
      case 'B':
      case 'C':
      case 'D':

      Informacao += customKey;
      lcd.print(customKey);
      break;

      case '*':
      Informacao = "";
      lcd.clear();
      inicio();
      break;

      case  '#':
      lcd.clear();
      if (Informacao == Deposito_1)
      {
        lcd.setCursor(3,0);
        lcd.print("1 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_1();
      }
      if (Informacao == Deposito_2)
      {
        lcd.setCursor(3,0);
        lcd.print("2 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_2();
      }
      if (Informacao == Deposito_3)
      {
        lcd.setCursor(3,0);
        lcd.print("3 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_3();
      }
      if (Informacao == Deposito_4)
      {
        lcd.setCursor(3,0);
        lcd.print("4 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_4();
      }
      if (Informacao == Deposito_5)
      {
        lcd.setCursor(3,0);
        lcd.print("5 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_5();
      }
      if (Informacao == Deposito_6)
      {
        lcd.setCursor(3,0);
        lcd.print("6 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_6();
      }
      if (Informacao == Deposito_7)
      {
        lcd.setCursor(3,0);
        lcd.print("7 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_7();
      }
      if (Informacao == Deposito_8)
      {
        lcd.setCursor(3,0);
        lcd.print("8 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_8();
      }
      if (Informacao == Deposito_9)
      {
        lcd.setCursor(3,0);
        lcd.print("9 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        DP_9();
      }
      if (Informacao == Retirada_1)
      {
        lcd.setCursor(3,0);
        lcd.print("1 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_1();
      }
      if (Informacao == Retirada_2)
      {
        lcd.setCursor(3,0);
        lcd.print("2 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_2();
      }
      if (Informacao == Retirada_3)
      {
        lcd.setCursor(3,0);
        lcd.print("3 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_3();
      }
      if (Informacao == Retirada_4)
      {
        lcd.setCursor(3,0);
        lcd.print("4 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_4();
      }
      if (Informacao == Retirada_5)
      {
        lcd.setCursor(3,0);
        lcd.print("5 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_5();
      }
      if (Informacao == Retirada_6)
      {
        lcd.setCursor(3,0);
        lcd.print("6 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_6();
      }
      if (Informacao == Retirada_7)
      {
        lcd.setCursor(3,0);
        lcd.print("7 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_7();
      }
      if (Informacao == Retirada_8)
      {
        lcd.setCursor(3,0);
        lcd.print("8 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_8();
      }
      if (Informacao == Retirada_9)
      {
        lcd.setCursor(3,0);
        lcd.print("9 Andar");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        RT_9();
      }
      if (Informacao == Modo_Auto)
      {
        lcd.setCursor(0,0);
        lcd.print("Modo automatico");
        lcd.setCursor(2,1);
        lcd.print("Selecionado");
        AUTO_MODE();
      }
      delay(2000);
      lcd.clear();
      Informacao = "";
      inicio();
      break;
    }
  }
}

//FUNÇÃO DE DEPOSITO DO PRIMEIRO ANDAR 
void DP_1()
{
  if (digitalRead(sensor_1_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_1_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_1_VOLTA()
{
  if (digitalRead(sensor_1)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 650; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}  

//FUNÇÃO DE DEPOSITO DO SEGUNDO ANDAR 
void DP_2()
{
  if (digitalRead(sensor_2_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_2_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_2_VOLTA()
{
  if (digitalRead(sensor_2)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 650; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 600; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}    

//FUNÇÃO DE DEPOSITO DO TERCEIRO ANDAR 
void DP_3()
{
  if (digitalRead(sensor_3_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_3_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_3_VOLTA()
{
  if (digitalRead(sensor_3)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 650; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 400; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}   
 
//FUNÇÃO DE DEPOSITO DO QUARTO ANDAR 
void DP_4()
{
  if (digitalRead(sensor_4_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_4_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_4_VOLTA()
{
  if (digitalRead(sensor_4)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 650; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 200; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}  

//FUNÇÃO DE DEPOSITO DO QUINTO ANDAR 
void DP_5()
{
  if (digitalRead(sensor_5_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_5_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_5_VOLTA()
{
  if (digitalRead(sensor_5)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 450; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}  

//FUNÇÃO DE DEPOSITO DO SEXTO ANDAR 
void DP_6()
{
  if (digitalRead(sensor_6_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_6_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_6_VOLTA()
{
  if (digitalRead(sensor_6)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 450; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 600; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}    

//FUNÇÃO DE DEPOSITO DO SÉTIMO ANDAR 
void DP_7()
{
  if (digitalRead(sensor_7_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_7_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_7_VOLTA()
{
  if (digitalRead(sensor_7)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 450; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 400; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}   

//FUNÇÃO DE DEPOSITO DO OITAVO ANDAR 
void DP_8()
{
  if (digitalRead(sensor_8_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_8_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_8_VOLTA()
{
  if (digitalRead(sensor_8)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 450; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 200; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}  

//FUNÇÃO DE DEPOSITO DO NOVE ANDAR 
void DP_9()
{
  if (digitalRead(sensor_9_PC)==1)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 100; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  DP_9_VOLTA();
  }
  else
  {
    ocupado();
  }
}

void DP_9_VOLTA()
{
  if (digitalRead(sensor_9)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  DEPOSITO();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 50; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 100; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}  

//MOVIMENTO PARA DEPOSITAR O MATERIAL
void DEPOSITO ()
{
  lcd.clear();
  lcd.setCursor(3,0);
  lcd.print("Depositando");
  lcd.setCursor(6,1);
  lcd.print("Peca");
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 50; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
}

//FUNÇÃO DE RETIRADA DO PRIMEIRO ANDAR 
void RT_1()
{
  if (digitalRead(sensor_1_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_1_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_1_VOLTA()
{
  if (digitalRead(sensor_1)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 600; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
  }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO SEGUNDO ANDAR 
void RT_2()
{
  if (digitalRead(sensor_2_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_2_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_2_VOLTA()
{
  if (digitalRead(sensor_2)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 600; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 600; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO TERCEIRO ANDAR 
void RT_3()
{
  if (digitalRead(sensor_3_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_3_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_3_VOLTA()
{
  if (digitalRead(sensor_3)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 600; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 400; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO QUARTO ANDAR 
void RT_4()
{
  if (digitalRead(sensor_4_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 600; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_4_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_4_VOLTA()
{
  if (digitalRead(sensor_4)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 650; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 600; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 200; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO QUINTO ANDAR 
void RT_5()
{
  if (digitalRead(sensor_5_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_5_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_5_VOLTA()
{
  if (digitalRead(sensor_5)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 400; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    } 
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO SEXTO ANDAR 
void RT_6()
{
  if (digitalRead(sensor_6_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_6_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_6_VOLTA()
{
  if (digitalRead(sensor_6)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 600; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 400; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 600; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO SÉTIMO ANDAR 
void RT_7()
{
  if (digitalRead(sensor_7_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_7_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_7_VOLTA()
{
  if (digitalRead(sensor_7)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 400; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 400; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 400; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO OITAVO ANDAR 
void RT_8()
{
  if (digitalRead(sensor_8_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 400; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_8_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_8_VOLTA()
{
  if (digitalRead(sensor_8)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 450; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 200; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 400; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 200; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//FUNÇÃO DE RETIRADA DO NONO ANDAR 
void RT_9()
{
  if (digitalRead(sensor_9_PC)==0)
  {
  analogWrite(dirPin_X,  LOW);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 100; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  } 
  delay(3000); 
  RT_9_VOLTA();
  }
  else
  {
    vazio();
  }
}

void RT_9_VOLTA()
{
  if (digitalRead(sensor_9)==0)
  {
  digitalWrite(dirPin_Z, LOW);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000); 
  }
  delay(3000);
  RETIRADA();
  //Volta para posição inicial
  lcd.setCursor(2,0);
  lcd.print("Voltando Pos");
  lcd.setCursor(5,1);
  lcd.print("Inicial");
  digitalWrite(dirPin_Z, HIGH);
  for(int Z = 0; Z < 100; Z++) {
  digitalWrite(stepPin_Z, LOW);
  delayMicroseconds(2000);
  digitalWrite(stepPin_Z, HIGH);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_Y, LOW);
  for(int Y = 0; Y < 150; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
  analogWrite(dirPin_X,  HIGH);
  for(int X = 0; X < 800; X++) {
  analogWrite(stepPin_X, LOW);
  delayMicroseconds(2000);
  analogWrite(stepPin_X, HIGH);
  delayMicroseconds(2000);
  }
  }
  else //Em caso de erro os motores que ja fizeram movimeto retornam para posição 0 
  {
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Erro Detectado");
    delay(2000);
    lcd.clear();
    lcd.setCursor(2,0);
    lcd.print("Voltando Pos");
    lcd.setCursor(5,1);
    lcd.print("Inicial");
    analogWrite(dirPin_Y, LOW);
    for(int Y = 0; Y < 100; Y++) {
    analogWrite(stepPin_Y, HIGH);
    delayMicroseconds(2000);
    analogWrite(stepPin_Y, LOW);
    delayMicroseconds(2000);
    }
    delay(2000);
    analogWrite(dirPin_X,  HIGH);
    for(int X = 0; X < 800; X++) {
    analogWrite(stepPin_X, LOW);
    delayMicroseconds(2000);
    analogWrite(stepPin_X, HIGH);
    delayMicroseconds(2000);
    }
    }
  delay(2000);
  lcd.clear();
}

//MOVIMENTO PARA RETIRAR O MATERIAL
void RETIRADA ()
{
  lcd.clear();
  lcd.setCursor(3,0);
  lcd.print("Retirando");
  lcd.setCursor(6,1);
  lcd.print("Peca");
  analogWrite(dirPin_Y, HIGH);
  for(int Y = 0; Y < 50; Y++) {
  analogWrite(stepPin_Y, HIGH);
  delayMicroseconds(2000);
  analogWrite(stepPin_Y, LOW);
  delayMicroseconds(2000);
  }
  delay(2000);
}

//Função de operação automática
void AUTO_MODE ()
{
  if (digitalRead(sensor_1_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("1 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_1();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("1 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_1();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_2_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("2 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_2();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("2 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_2();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_3_PC)==1)  
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("3 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_3();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("3 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_3();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_4_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("4 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_4();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("4 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_4();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material"); 
    delay(5000);
  if (digitalRead(sensor_5_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("5 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_5();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("5 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_5();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_6_PC)==1)  
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("6 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_6();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("6 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_6();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_7_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("7 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_7();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("7 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_7();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_8_PC)==1)
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("8 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_8();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("8 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_8();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
  if (digitalRead(sensor_9_PC)==1)  
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("9 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    DP_9();
  }
  else
  {
    lcd.clear();
    lcd.setCursor(3,0);
    lcd.print("9 Andar");
    lcd.setCursor(2,1);
    lcd.print("Selecionado");
    RT_9();
  }
    lcd.setCursor(6,0);
    lcd.print("Lendo");
    lcd.setCursor(4,1);
    lcd.print("Material");
    delay(5000);
}