RuiViana

Bobina_New

May 9th, 2020
210
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //  http://labdegaragem.com/forum/topics/bobinadeira-com-arduino
  2. /*
  3.    Nome do Projeto:  Bobinadeira
  4.    Nome do Aquivo:   bobinadeira_Botao13.ino
  5.    link:        http://labdegaragem.com/forum/topics/bobinadeira-autom-tica-controlada-com-arduino
  6.    Dependencias:     funcoes13.ino
  7.    MCU:              ATmega
  8.    Board:            Arduino Uno/Mega/Mini
  9.    Compilador        N/A
  10.    IDE:              Arduino IDE 1.8.5
  11.    Hardware:         Arduino UNO/MEGA/Mini
  12.    Escrito por:      Rui Viana
  13.    Modificado por:   N/A
  14.    Data:             23/06/2018
  15.    Uso:              Didático
  16.    Desenhos          CONTADOR2_SIMU.PDF
  17.    Copyright @       N/A
  18.  
  19.    Este programa é software livre;
  20.    e é distribuído na esperança que possa ser útil, mas SEM QUALQUER GARANTIA;
  21.    mesmo sem a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM DETERMINADO FIM.
  22.  
  23.   Feio.e quando termina a bobina, fazer um botão que inicia de novo uma nova bobina
  24.   sem ir pro menu e confg de novo.
  25.  
  26.   tambem ele esta girando só para um lado, quero se possivel que eu consiga escolher
  27.   o sentido de rotação do motor.
  28.  
  29. */
  30. //#define debug
  31. #include <LiquidCrystal.h>
  32.  
  33. #include <Stepper.h>                                        // Biblioteca para uso do step motor
  34. Stepper stepper(200, PA12, PA11);                           // Portas do step e steps por volta
  35.  
  36. LiquidCrystal lcd(PA5, PA4, PA3, PA2, PA1, PA0);
  37.  
  38. #define brk PB9                                              // Controle do break
  39. //Botoes para controle do menu
  40. #define BT1 PB8                                              //Enter                  
  41. #define BT2 PB7                                              //down
  42. #define BT3 PB6                                              //Left
  43. #define BT4 PB5                                              //Right
  44. #define BT5 PB4                                              //Up
  45. #define BT6 R                                                //Reset
  46.  
  47. #define encoder PA15                                          // Entrada do encoder do motor principal
  48.  
  49. int     numEsp         = 903;                               // Numero de espiras previstas
  50. float   bitFio         = 0.5;                                // Bitola do fio em mm
  51. float   carrLeng       = 26;                                // Comprimento do carretel
  52. int     numEspAtual    =  0;                                // Numero de espirar atuais
  53. bool    incrementou = false;                                // Controle de incremento de espiras
  54. int     espFase        =  1;                                // N de espiras por etapa
  55. int     espCam         =  0;                                // Calcula o numero de espira por camada
  56. int     camf           =  0;                                // Numero de camada feita
  57. float   dln            =  0;                                // Fator de correção de largura
  58. float   dciclos        =  0;                                // Fator de correção passo
  59. bool    isolador    = false;                                // Contrele de isolador de camada
  60. int     menu           =  0;                                // Telas do sistema
  61. int     cstep          =  0;                                // Contador de passos
  62. int     ciclos         =  0;                                // Calcula o numero de ciclos da guia linear para cada passo
  63. bool    direct         =  1;                                // Sentido da guia
  64. float   incrementa     =  1;                                // Offset de incremento
  65. bool    pause       = false;                                // Contrele de pause
  66. int contaStep = 0;
  67. // Controle do motor da bobina
  68.  
  69. #define  EnaA PA6                                             // Habilita motor
  70. #define  IN1 PB13                                             // Fase1 do motor
  71. #define  IN2 PB14                                             // Fase2 do motor
  72. #define  cntl PA7                                             // Central do pot
  73. int velocidade = 0;                                           // Velocidade do motor
  74. //---------------------------------------------------------
  75. void ligaMotor()
  76. {
  77.   digitalWrite(IN1, HIGH);
  78.   digitalWrite(IN2, LOW);
  79.   analogWrite(EnaA, velocidade);                            // PWM com o valor de velocidase calculado
  80. }
  81. //---------------------------------------------------------
  82. void desligaMotor()
  83. {
  84.   velocidade = 0;                                           // Zera velocidade
  85.   digitalWrite(IN1, HIGH);                                  //
  86.   digitalWrite(IN2, HIGH);                                  //
  87.   analogWrite(EnaA, velocidade);                            //
  88. }
  89. //---------------------------------------------------------
  90. void setup()
  91. {
  92.   Serial.begin(115200);
  93.   stepper.setSpeed(600);                                    // Define velocidade do step
  94.   lcd.begin(16, 2);                                         // Inicializa LCD
  95.   pinMode(encoder, INPUT);                                  // Encoder como INPUT
  96.   pinMode(brk, INPUT_PULLUP);                               // Break como INPUT
  97. #ifdef  debug
  98.   pinMode(encoder, INPUT_PULLUP);                           // Debug
  99. #endif
  100.   pinMode(BT1, INPUT_PULLUP);                               // Botoes como INPUT
  101.   pinMode(BT2, INPUT_PULLUP);
  102.   pinMode(BT3, INPUT_PULLUP);
  103.   pinMode(BT4, INPUT_PULLUP);
  104.   pinMode(BT5, INPUT_PULLUP);
  105.   desligaMotor();
  106.   // Controle do motor
  107.   pinMode(IN1, OUTPUT);                                     // Fase1 do motor
  108.   pinMode(IN2, OUTPUT);                                     // Fase2 do motor
  109.   pinMode(EnaA, OUTPUT);                                    // Habilita motor
  110.   pinMode(cntl, INPUT);                                     // Central do pot
  111.   digitalWrite(EnaA, HIGH);                                 // Habilita motor em HIGH
  112.   attachInterrupt(digitalPinToInterrupt(PA15), contagem, FALLING);
  113.   Serial.println("Iniciando......");
  114. }
  115. //--------------------------------------------------------
  116. void contagem()
  117. {
  118.   if (digitalRead(PA15) == HIGH)
  119.   {
  120.     numEspAtual++;
  121.     incrementou = true;                                     // Informa incremento de espiras
  122.     delay(10);
  123.   }
  124. }
  125. //--------------------------------------------------------
  126. void returnHome()
  127. {
  128.   if (direct == 0)
  129.   {
  130.     while ( contaStep > 0)
  131.     {
  132.       contaStep--;
  133.       stepper.step(-1);                                         // Retorna para o inicio
  134.     }
  135.   }
  136.   if (direct == 1)
  137.   {
  138.     while ( contaStep < 0)
  139.     {
  140.       contaStep++;
  141.       stepper.step(1);                                         // Retorna para o inicio
  142.     }
  143.   }
  144. }
  145. //---------------------------- LOOP -----------------------------
  146. void loop()
  147. {
  148.   int pot = 0;                                              // Variavel para receber o valor analogico
  149.   pot = analogRead(cntl);                                   // Le o port analogico
  150.   velocidade = map(pot, 0, 4095, 20, 252);                  // Converte o valor
  151.   Serial.print("velocidade  "); Serial.println(velocidade);
  152.   selecao();                                                // Rotina IHM
  153.   cstep = 0;                                                // Zera contador de passos do step
  154.   ligaMotor();
  155.   if (incrementou == true)                                  // Houve incremento de espiras
  156.   {
  157.     LCDContagem();                                          // Mostra contagem de espiras e camadas
  158.     incrementou = false;                                    // Desabilita informar incremento de espiras
  159.     if (numEspAtual >= numEsp)                              // Numero de espiras realizadas = num de espiras esperadas
  160.     {
  161.       desligaMotor();
  162.       endProcess();                                         // Para processo
  163.     }
  164.     if (numEspAtual < numEsp)                               // Numero de espiras realizadas < num de espiras esperadas
  165.     {
  166.       if (direct != LOW)                                    // Se direcao e CW
  167.       {
  168.         while (cstep < ciclos)                              // Enquanto contagem de passos for menor que ciclos
  169.         {
  170.           clockwise();                                      // Gira um step CW
  171.           cstep = cstep + 1;                                // Incrementa contador de passos
  172.         }
  173.       }
  174.       else                                                  // Se direcao e CCW
  175.       {
  176.         while (cstep < ciclos)                              // Enquanto contagem de passos for menor que ciclos
  177.         {
  178.           counterclockwise();                               // Gira um step CCW
  179.           cstep = cstep + 1;                                // Incrementa contador de passos
  180.         }
  181.       }
  182.       if (numEspAtual % espCam == 0)                        // Se modulo de qte de espiras por camada = 0
  183.       {
  184.         camf++;                                             // Incremen ta contador de camadas
  185.         LCDContagem();                                      // Mostra contagem de espiras e camadas
  186.         direct = not(direct);                               // Inverte direcao do step
  187.         if (isolador == true)                               // Se precisa de isolador ligado
  188.         {
  189.           desligaMotor();
  190.           int t = 0;                                        // Define t como inteiro e igual a zero  ??
  191.           for (t = 0; t < 50;)                              // Faca 50 vezes ??
  192.           {
  193.             if (digitalRead(brk) == 0)                      // Se o brake foi pressionado
  194.             {
  195.               delay(500);                                   // Delay
  196.               break;                                        // termine o for
  197.             }
  198.           }
  199.         }
  200.       }
  201.       while (pause == HIGH)
  202.       {
  203.         desligaMotor();
  204.         if (digitalRead(brk) == 0)                            // Se o brake foi pressionado
  205.         {
  206.           delay(200);                                          // Debouncing
  207.           if (digitalRead(brk) == 0)                          // Se o brake continua pressionado
  208.           {
  209.             pause = LOW;                                      // Desabilita pause
  210.             delay(500);                                       // Delay
  211.           }
  212.         }
  213.       }
  214.     }
  215.   }
  216.   if (digitalRead(brk) == 0)                                // Se o brake foi pressionado
  217.   {
  218.     delay(30);                                              // Debouncing
  219.     if (digitalRead(brk) == 0)                              // Se o brake continua pressionado
  220.     {
  221.       pause = HIGH;                                         // Habilita pause
  222.     }
  223.   }
  224. }
RAW Paste Data