Bobina_New

//  http://labdegaragem.com/forum/topics/bobinadeira-com-arduino
/*
   Nome do Projeto:  Bobinadeira
   Nome do Aquivo:   bobinadeira_Botao13.ino
   link:        http://labdegaragem.com/forum/topics/bobinadeira-autom-tica-controlada-com-arduino
   Dependencias:     funcoes13.ino
   MCU:              ATmega
   Board:            Arduino Uno/Mega/Mini
   Compilador        N/A
   IDE:              Arduino IDE 1.8.5
   Hardware:         Arduino UNO/MEGA/Mini
   Escrito por:      Rui Viana
   Modificado por:   N/A
   Data:             23/06/2018
   Uso:              Didático
   Desenhos          CONTADOR2_SIMU.PDF
   Copyright @       N/A

   Este programa é software livre;
   e é distribuído na esperança que possa ser útil, mas SEM QUALQUER GARANTIA;
   mesmo sem a garantia implícita de COMERCIALIZAÇÃO ou ADEQUAÇÃO A UM DETERMINADO FIM.

  Feio.e quando termina a bobina, fazer um botão que inicia de novo uma nova bobina
  sem ir pro menu e confg de novo.

  tambem ele esta girando só para um lado, quero se possivel que eu consiga escolher
  o sentido de rotação do motor.

*/
//#define debug
#include <LiquidCrystal.h>

#include <Stepper.h>                                        // Biblioteca para uso do step motor
Stepper stepper(200, PA12, PA11);                           // Portas do step e steps por volta

LiquidCrystal lcd(PA5, PA4, PA3, PA2, PA1, PA0);

#define brk PB9                                              // Controle do break
//Botoes para controle do menu
#define BT1 PB8                                              //Enter
#define BT2 PB7                                              //down
#define BT3 PB6                                              //Left
#define BT4 PB5                                              //Right
#define BT5 PB4                                              //Up
#define BT6 R                                                //Reset

#define encoder PA15                                          // Entrada do encoder do motor principal

int     numEsp         = 903;                               // Numero de espiras previstas
float   bitFio         = 0.5;                                // Bitola do fio em mm
float   carrLeng       = 26;                                // Comprimento do carretel
int     numEspAtual    =  0;                                // Numero de espirar atuais
bool    incrementou = false;                                // Controle de incremento de espiras
int     espFase        =  1;                                // N de espiras por etapa
int     espCam         =  0;                                // Calcula o numero de espira por camada
int     camf           =  0;                                // Numero de camada feita
float   dln            =  0;                                // Fator de correção de largura
float   dciclos        =  0;                                // Fator de correção passo
bool    isolador    = false;                                // Contrele de isolador de camada
int     menu           =  0;                                // Telas do sistema
int     cstep          =  0;                                // Contador de passos
int     ciclos         =  0;                                // Calcula o numero de ciclos da guia linear para cada passo
bool    direct         =  1;                                // Sentido da guia
float   incrementa     =  1;                                // Offset de incremento
bool    pause       = false;                                // Contrele de pause
int contaStep = 0;
// Controle do motor da bobina

#define  EnaA PA6                                             // Habilita motor
#define  IN1 PB13                                             // Fase1 do motor
#define  IN2 PB14                                             // Fase2 do motor
#define  cntl PA7                                             // Central do pot
int velocidade = 0;                                           // Velocidade do motor
//---------------------------------------------------------
void ligaMotor()
{
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(EnaA, velocidade);                            // PWM com o valor de velocidase calculado
}
//---------------------------------------------------------
void desligaMotor()
{
  velocidade = 0;                                           // Zera velocidade
  digitalWrite(IN1, HIGH);                                  //
  digitalWrite(IN2, HIGH);                                  //
  analogWrite(EnaA, velocidade);                            //
}
//---------------------------------------------------------
void setup()
{
  Serial.begin(115200);
  stepper.setSpeed(600);                                    // Define velocidade do step
  lcd.begin(16, 2);                                         // Inicializa LCD
  pinMode(encoder, INPUT);                                  // Encoder como INPUT
  pinMode(brk, INPUT_PULLUP);                               // Break como INPUT
#ifdef  debug
  pinMode(encoder, INPUT_PULLUP);                           // Debug
#endif
  pinMode(BT1, INPUT_PULLUP);                               // Botoes como INPUT
  pinMode(BT2, INPUT_PULLUP);
  pinMode(BT3, INPUT_PULLUP);
  pinMode(BT4, INPUT_PULLUP);
  pinMode(BT5, INPUT_PULLUP);
  desligaMotor();
  // Controle do motor
  pinMode(IN1, OUTPUT);                                     // Fase1 do motor
  pinMode(IN2, OUTPUT);                                     // Fase2 do motor
  pinMode(EnaA, OUTPUT);                                    // Habilita motor
  pinMode(cntl, INPUT);                                     // Central do pot
  digitalWrite(EnaA, HIGH);                                 // Habilita motor em HIGH
  attachInterrupt(digitalPinToInterrupt(PA15), contagem, FALLING);
  Serial.println("Iniciando......");
}
//--------------------------------------------------------
void contagem()
{
  if (digitalRead(PA15) == HIGH)
  {
    numEspAtual++;
    incrementou = true;                                     // Informa incremento de espiras
    delay(10);
  }
}
//--------------------------------------------------------
void returnHome()
{
  if (direct == 0)
  {
    while ( contaStep > 0)
    {
      contaStep--;
      stepper.step(-1);                                         // Retorna para o inicio
    }
  }
  if (direct == 1)
  {
    while ( contaStep < 0)
    {
      contaStep++;
      stepper.step(1);                                         // Retorna para o inicio
    }
  }
}
//---------------------------- LOOP -----------------------------
void loop()
{
  int pot = 0;                                              // Variavel para receber o valor analogico
  pot = analogRead(cntl);                                   // Le o port analogico
  velocidade = map(pot, 0, 4095, 20, 252);                  // Converte o valor
  Serial.print("velocidade  "); Serial.println(velocidade);
  selecao();                                                // Rotina IHM
  cstep = 0;                                                // Zera contador de passos do step
  ligaMotor();
  if (incrementou == true)                                  // Houve incremento de espiras
  {
    LCDContagem();                                          // Mostra contagem de espiras e camadas
    incrementou = false;                                    // Desabilita informar incremento de espiras
    if (numEspAtual >= numEsp)                              // Numero de espiras realizadas = num de espiras esperadas
    {
      desligaMotor();
      endProcess();                                         // Para processo
    }
    if (numEspAtual < numEsp)                               // Numero de espiras realizadas < num de espiras esperadas
    {
      if (direct != LOW)                                    // Se direcao e CW
      {
        while (cstep < ciclos)                              // Enquanto contagem de passos for menor que ciclos
        {
          clockwise();                                      // Gira um step CW
          cstep = cstep + 1;                                // Incrementa contador de passos
        }
      }
      else                                                  // Se direcao e CCW
      {
        while (cstep < ciclos)                              // Enquanto contagem de passos for menor que ciclos
        {
          counterclockwise();                               // Gira um step CCW
          cstep = cstep + 1;                                // Incrementa contador de passos
        }
      }
      if (numEspAtual % espCam == 0)                        // Se modulo de qte de espiras por camada = 0
      {
        camf++;                                             // Incremen ta contador de camadas
        LCDContagem();                                      // Mostra contagem de espiras e camadas
        direct = not(direct);                               // Inverte direcao do step
        if (isolador == true)                               // Se precisa de isolador ligado
        {
          desligaMotor();
          int t = 0;                                        // Define t como inteiro e igual a zero  ??
          for (t = 0; t < 50;)                              // Faca 50 vezes ??
          {
            if (digitalRead(brk) == 0)                      // Se o brake foi pressionado
            {
              delay(500);                                   // Delay
              break;                                        // termine o for
            }
          }
        }
      }
      while (pause == HIGH)
      {
        desligaMotor();
        if (digitalRead(brk) == 0)                            // Se o brake foi pressionado
        {
          delay(200);                                          // Debouncing
          if (digitalRead(brk) == 0)                          // Se o brake continua pressionado
          {
            pause = LOW;                                      // Desabilita pause
            delay(500);                                       // Delay
          }
        }
      }
    }
  }
  if (digitalRead(brk) == 0)                                // Se o brake foi pressionado
  {
    delay(30);                                              // Debouncing
    if (digitalRead(brk) == 0)                              // Se o brake continua pressionado
    {
      pause = HIGH;                                         // Habilita pause
    }
  }
}