Controle_Garafas

/*// Programa: envasadora linear
  // Autor: Alexandre

  Uma esteira possui 2 sensores posicionados um após o outro
    Sensor 1 e Sensor 2.
    5 reles atuadores.  Motor da esteira, bomba de enchimento, 3 pistões.
  Parte elétrica da esteira totalmente 12vcc.

  O fluxo do processo deve acontecer em 2 estágios.
  1º estagio deve encher a garrafa, para tal a esteira deve estar parada.
  2º estagio deve tampar a garrafa, para tal deve acontecer no momento em que a esteira esta parada
      e enchendo (simultâneo com o 1º estagio).

  Funcionamento da esteira:

  --1º estágio: encher a garrafa.
  -Liga a esteira, botão on/off.
  -Motor da esteira ligado;
  -Sensor 1 identifica uma garrafa;
  -Para o motor da esteira imediatamente sob um bico de envase;
  -Após 2 segundos, aciona o pistão 1 (bico) que penetra 25mm dentro da garrafa.
  -Após 2 segundos, liga a bomba de envase por 6 segundos (tempo de enchimento da garrafa).
  -Desliga a bomba de envase;
  -Após 2 segundos recua o pistão 1;
  -Após 2 segundos liga o motor da esteira novamente;

  Ciclo do 1º estágio consegui deixar funcionando com sucesso usando as linhas abaixo!

  Inicio do 2º Estágio: Tampar a garrafa.

  -Sensor 2 identifica uma garrafa;

  ------- >>>> correção  - pare o motor

  -aciona imediatamente o pistão 2 (e mantém acionado) para segurar a garrafa sob uma prensa (nesse momento o
       motor da esteira ainda continua ligado);
  -acontece uma condição:
  -se tiver uma garrafa em frente ao sensor 2 e o motor da esteira parou (devido ao estagio 1), então aciona
      pistão 3 por 2 segundos(tempo que leva para realizar o lacre da tampa) que é responsável por lacrar a
      tampa da garrafa que é por encaixe prensado.
  -após esse ciclo de lacrar a garrafa, o pistão 2 e 3 já pode voltar imediatamente ao estado inicial (recuado)
      e espera o motor esteira ser ligado novamente.

  Esse é o fluxo da esteira e os processos de envase, o problema enfrentado é que enquanto o estagio 1 esta
      acontecendo, não consigo ler o sensor 2 devido aos delays.

  //PROGRAMAÇÃO

*/
int pino_bomba = 7;
int pino_motor = 3;
int pino_pistao_1 = 6;
int pino_pistao_2 = 5;
int pino_pistao_3 = 4;
int pino_sensor_1 = 10;
int pino_sensor_2 = 9;
int estado_sensor_1 = 0;
int estado_sensor_2 = 0;
int irread1  = 1;
int irread2  = 1;
unsigned long Tempo1;
unsigned long Tempo2;
byte FlagFase0 = 0;
byte FlagFase1 = 0;
byte FlagFase2 = 0;
byte FlagFase3 = 0;
byte FlagFase4 = 0;
byte FlagFase5 = 0;
byte FlagFase6 = 0;
byte FlagFase7 = 0;

//--------------------------------------
void setup()
{
  Serial.begin(9600);
  pinMode(pino_sensor_1, INPUT);                  // Define o pino do sensor como entrada
  pinMode(pino_sensor_2, INPUT);
  pinMode(pino_pistao_1, OUTPUT);                 // Define os pinos dos reles dos pistoes, bomba e motor como saida
  pinMode(pino_pistao_2, OUTPUT);
  pinMode(pino_pistao_3, OUTPUT);
  pinMode(pino_motor, OUTPUT);
  pinMode(pino_bomba, OUTPUT);
  Tempo1 = millis();
  Tempo2 = millis();
}
//--------------------------------------
void loop()
{
  irread1 = digitalRead(pino_sensor_1);           // declara uma variável para leitura da porta sensor 1
  irread2 = digitalRead(pino_sensor_2);           // declara uma variável para leitura da porta sensor 2
  Serial.println(irread1);                        // escreve a váriavel no Monitor Serial
  Serial.println(irread2);
  Sensor1();                                      // Chama rotina do sensor 1
  Sensor2();                                      // Chama rotina do sensor 2
}
//--------------------------------------  //SENSOR 1
void Sensor1()
{
  if (irread1 == 1)                               // se sensor for 1 é porque não há nada sendo identificado (Mantem o motor ligado e o restante desligado
  {
    digitalWrite(pino_motor, LOW);
    digitalWrite(pino_bomba, HIGH);
    digitalWrite(pino_pistao_1, 1);
  }
  if (irread1 == 0)                                 // se igual a 0 é porque o sensor detectou algo      //pegou sinal da garrafa
  {
    if (FlagFase0 == 0)                             // Se ainda não inicializou o tempo1
    {
      Tempo1 = millis();                            // Inicialisa o tempo1
      FlagFase0 = 1;                                // Informa que inicializou
    }
    digitalWrite(pino_motor, 1);                    // desligar o motor
    if (((millis() - Tempo1) >= 2000)  & (FlagFase1 == 0))  // +2 seg se ainda não executou
    {
      digitalWrite(pino_pistao_1, 0);               // ligar o pistao
      FlagFase1 = 1;                                // já executou
    }
    if (((millis() - Tempo1) >= 4000)  & (FlagFase2 == 0))  // +2 seg se ainda não executou
    {
      digitalWrite(pino_bomba, 0);                  // liga a bomba
      FlagFase2 = 1;                                // já executou                          // já executou
    }
    if (((millis() - Tempo1) >= 10000)  & (FlagFase3 == 0))  // +6 seg se ainda não executou
    {
      digitalWrite(pino_bomba, 1);                  // desliga a bomba
      FlagFase3 = 1;                                // já executou
    }
    if (((millis() - Tempo1) >= 12000)  & (FlagFase4 == 0))  // +2 seg se ainda não executou
    {
      digitalWrite(pino_pistao_1, 1);               // desliga o pistao
      FlagFase4 = 1;                                // já executou
    }
    if ((millis() - Tempo1) >= 14000)               // +2 seg
    {
      digitalWrite(pino_motor, 0);                  // liga o motor novamente
      FlagFase0 = 0;                                // zera flag de execução
      FlagFase1 = 0;
      FlagFase2 = 0;
      FlagFase3 = 0;
      FlagFase4 = 0;
    }
  }
}
//-------------------------------------- // SENSOR 2
void Sensor2()
{
  if (irread2 == 1)                                 // se sensor for 1 é porque não há nada sendo identificado (Mantem o motor ligado e o restante desligado
  {
    digitalWrite(pino_pistao_2, 1);
    digitalWrite(pino_pistao_3, 1);
  }
  if (irread2 == 0)                                 // se igual a 0 é porque o sensor detectou algo      //pegou sinal da garrafa
  {
    if (FlagFase7 == 0)
    {
      digitalWrite(pino_pistao_2, 0);               // ligar o pistao
      digitalWrite(pino_motor, 1);                  // pare o motor
      FlagFase7 == 1;
    }
    if (FlagFase5 == 0)                           // Se ainda não inicializou o tempo1
    {
      Tempo2 = millis();                          // Inicialisa o tempo1
      FlagFase5 = 1;                              // Informa que inicializou
    }
    if (((millis() - Tempo2) >= 2000)  & (FlagFase6 == 0))
    {
      digitalWrite(pino_pistao_3, 0);             // ligar o pistao
      FlagFase6 = 1;                              // já executou
    }
    if ((millis() - Tempo2) >= 4000)              // +2 seg se ainda não executou
    {
      digitalWrite(pino_pistao_3, 1);             // desligar o pistao
      digitalWrite(pino_pistao_2, 1);             // desligar o pistao
      FlagFase5 = 0;                              // zera flag de execução
      FlagFase6 = 0;

      //      if (irread1 == 0)                           // Se o sensor 0 esta livre
      //      {
      digitalWrite(pino_motor, 0);              // ligue o motor
      FlagFase7 = 0;
      //      }
    }
  }
}
/*
     S        S
  ___G________G_________    motor On
  _____G________G_______    motor Off  2 seg  pistão 1 On  2 seg  bomba On  6 seg  bomba off  2 seg  pistão 1 Off  2 seg  motor On
  ________G________G_______    motor On
  __________G________G_______    motor On
  ____G________G________G_______     motor Off  2 seg  pistão 1 On  2 seg  bomba On  6 seg  bomba off  2 seg  pistão 1 Off  2 seg  motor On
*/