RuiViana

Controle_Garafas

Oct 4th, 2016
185
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*// Programa: envasadora linear
  2.   // Autor: Alexandre
  3.  
  4.   Uma esteira possui 2 sensores posicionados um após o outro
  5.     Sensor 1 e Sensor 2.
  6.     5 reles atuadores.  Motor da esteira, bomba de enchimento, 3 pistões.
  7.   Parte elétrica da esteira totalmente 12vcc.
  8.  
  9.   O fluxo do processo deve acontecer em 2 estágios.
  10.   1º estagio deve encher a garrafa, para tal a esteira deve estar parada.
  11.   2º estagio deve tampar a garrafa, para tal deve acontecer no momento em que a esteira esta parada
  12.       e enchendo (simultâneo com o 1º estagio).
  13.  
  14.   Funcionamento da esteira:
  15.  
  16.   --1º estágio: encher a garrafa.
  17.   -Liga a esteira, botão on/off.
  18.   -Motor da esteira ligado;
  19.   -Sensor 1 identifica uma garrafa;
  20.   -Para o motor da esteira imediatamente sob um bico de envase;
  21.   -Após 2 segundos, aciona o pistão 1 (bico) que penetra 25mm dentro da garrafa.
  22.   -Após 2 segundos, liga a bomba de envase por 6 segundos (tempo de enchimento da garrafa).
  23.   -Desliga a bomba de envase;
  24.   -Após 2 segundos recua o pistão 1;
  25.   -Após 2 segundos liga o motor da esteira novamente;
  26.  
  27.   Ciclo do 1º estágio consegui deixar funcionando com sucesso usando as linhas abaixo!
  28.  
  29.   Inicio do 2º Estágio: Tampar a garrafa.
  30.  
  31.   -Sensor 2 identifica uma garrafa;
  32.  
  33.   ------- >>>> correção  - pare o motor
  34.  
  35.   -aciona imediatamente o pistão 2 (e mantém acionado) para segurar a garrafa sob uma prensa (nesse momento o
  36.        motor da esteira ainda continua ligado);
  37.   -acontece uma condição:
  38.   -se tiver uma garrafa em frente ao sensor 2 e o motor da esteira parou (devido ao estagio 1), então aciona
  39.       pistão 3 por 2 segundos(tempo que leva para realizar o lacre da tampa) que é responsável por lacrar a
  40.       tampa da garrafa que é por encaixe prensado.
  41.   -após esse ciclo de lacrar a garrafa, o pistão 2 e 3 já pode voltar imediatamente ao estado inicial (recuado)
  42.       e espera o motor esteira ser ligado novamente.
  43.  
  44.   Esse é o fluxo da esteira e os processos de envase, o problema enfrentado é que enquanto o estagio 1 esta
  45.       acontecendo, não consigo ler o sensor 2 devido aos delays.
  46.  
  47.   //PROGRAMAÇÃO
  48.  
  49. */
  50. int pino_bomba = 7;
  51. int pino_motor = 3;
  52. int pino_pistao_1 = 6;
  53. int pino_pistao_2 = 5;
  54. int pino_pistao_3 = 4;
  55. int pino_sensor_1 = 10;
  56. int pino_sensor_2 = 9;
  57. int estado_sensor_1 = 0;
  58. int estado_sensor_2 = 0;
  59. int irread1  = 1;
  60. int irread2  = 1;
  61. unsigned long Tempo1;
  62. unsigned long Tempo2;
  63. byte FlagFase0 = 0;
  64. byte FlagFase1 = 0;
  65. byte FlagFase2 = 0;
  66. byte FlagFase3 = 0;
  67. byte FlagFase4 = 0;
  68. byte FlagFase5 = 0;
  69. byte FlagFase6 = 0;
  70. byte FlagFase7 = 0;
  71.  
  72. //--------------------------------------
  73. void setup()
  74. {
  75.   Serial.begin(9600);
  76.   pinMode(pino_sensor_1, INPUT);                  // Define o pino do sensor como entrada
  77.   pinMode(pino_sensor_2, INPUT);
  78.   pinMode(pino_pistao_1, OUTPUT);                 // Define os pinos dos reles dos pistoes, bomba e motor como saida
  79.   pinMode(pino_pistao_2, OUTPUT);
  80.   pinMode(pino_pistao_3, OUTPUT);
  81.   pinMode(pino_motor, OUTPUT);
  82.   pinMode(pino_bomba, OUTPUT);
  83.   Tempo1 = millis();
  84.   Tempo2 = millis();
  85. }
  86. //--------------------------------------
  87. void loop()
  88. {
  89.   irread1 = digitalRead(pino_sensor_1);           // declara uma variável para leitura da porta sensor 1
  90.   irread2 = digitalRead(pino_sensor_2);           // declara uma variável para leitura da porta sensor 2
  91.   Serial.println(irread1);                        // escreve a váriavel no Monitor Serial
  92.   Serial.println(irread2);
  93.   Sensor1();                                      // Chama rotina do sensor 1
  94.   Sensor2();                                      // Chama rotina do sensor 2
  95. }
  96. //--------------------------------------  //SENSOR 1
  97. void Sensor1()
  98. {
  99.   if (irread1 == 1)                               // se sensor for 1 é porque não há nada sendo identificado (Mantem o motor ligado e o restante desligado
  100.   {
  101.     digitalWrite(pino_motor, LOW);
  102.     digitalWrite(pino_bomba, HIGH);
  103.     digitalWrite(pino_pistao_1, 1);
  104.   }
  105.   if (irread1 == 0)                                 // se igual a 0 é porque o sensor detectou algo      //pegou sinal da garrafa
  106.   {
  107.     if (FlagFase0 == 0)                             // Se ainda não inicializou o tempo1
  108.     {
  109.       Tempo1 = millis();                            // Inicialisa o tempo1
  110.       FlagFase0 = 1;                                // Informa que inicializou
  111.     }
  112.     digitalWrite(pino_motor, 1);                    // desligar o motor
  113.     if (((millis() - Tempo1) >= 2000)  & (FlagFase1 == 0))  // +2 seg se ainda não executou
  114.     {
  115.       digitalWrite(pino_pistao_1, 0);               // ligar o pistao
  116.       FlagFase1 = 1;                                // já executou
  117.     }
  118.     if (((millis() - Tempo1) >= 4000)  & (FlagFase2 == 0))  // +2 seg se ainda não executou
  119.     {
  120.       digitalWrite(pino_bomba, 0);                  // liga a bomba
  121.       FlagFase2 = 1;                                // já executou                          // já executou
  122.     }
  123.     if (((millis() - Tempo1) >= 10000)  & (FlagFase3 == 0))  // +6 seg se ainda não executou
  124.     {
  125.       digitalWrite(pino_bomba, 1);                  // desliga a bomba
  126.       FlagFase3 = 1;                                // já executou
  127.     }
  128.     if (((millis() - Tempo1) >= 12000)  & (FlagFase4 == 0))  // +2 seg se ainda não executou
  129.     {
  130.       digitalWrite(pino_pistao_1, 1);               // desliga o pistao
  131.       FlagFase4 = 1;                                // já executou
  132.     }
  133.     if ((millis() - Tempo1) >= 14000)               // +2 seg
  134.     {
  135.       digitalWrite(pino_motor, 0);                  // liga o motor novamente
  136.       FlagFase0 = 0;                                // zera flag de execução
  137.       FlagFase1 = 0;
  138.       FlagFase2 = 0;
  139.       FlagFase3 = 0;
  140.       FlagFase4 = 0;
  141.     }
  142.   }
  143. }
  144. //-------------------------------------- // SENSOR 2
  145. void Sensor2()
  146. {
  147.   if (irread2 == 1)                                 // se sensor for 1 é porque não há nada sendo identificado (Mantem o motor ligado e o restante desligado
  148.   {
  149.     digitalWrite(pino_pistao_2, 1);
  150.     digitalWrite(pino_pistao_3, 1);
  151.   }
  152.   if (irread2 == 0)                                 // se igual a 0 é porque o sensor detectou algo      //pegou sinal da garrafa
  153.   {
  154.     if (FlagFase7 == 0)
  155.     {
  156.       digitalWrite(pino_pistao_2, 0);               // ligar o pistao
  157.       digitalWrite(pino_motor, 1);                  // pare o motor
  158.       FlagFase7 == 1;
  159.     }
  160.     if (FlagFase5 == 0)                           // Se ainda não inicializou o tempo1
  161.     {
  162.       Tempo2 = millis();                          // Inicialisa o tempo1
  163.       FlagFase5 = 1;                              // Informa que inicializou
  164.     }
  165.     if (((millis() - Tempo2) >= 2000)  & (FlagFase6 == 0))
  166.     {
  167.       digitalWrite(pino_pistao_3, 0);             // ligar o pistao
  168.       FlagFase6 = 1;                              // já executou
  169.     }
  170.     if ((millis() - Tempo2) >= 4000)              // +2 seg se ainda não executou
  171.     {
  172.       digitalWrite(pino_pistao_3, 1);             // desligar o pistao
  173.       digitalWrite(pino_pistao_2, 1);             // desligar o pistao
  174.       FlagFase5 = 0;                              // zera flag de execução
  175.       FlagFase6 = 0;
  176.  
  177.       //      if (irread1 == 0)                           // Se o sensor 0 esta livre
  178.       //      {
  179.       digitalWrite(pino_motor, 0);              // ligue o motor
  180.       FlagFase7 = 0;
  181.       //      }
  182.     }
  183.   }
  184. }
  185. /*
  186.      S        S
  187.   ___G________G_________    motor On
  188.   _____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
  189.   ________G________G_______    motor On
  190.   __________G________G_______    motor On
  191.   ____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
  192. */
RAW Paste Data