MohanCurtain.ino

#define DIR_PIN                4    //  Working
#define STEP_PIN               5    //
#define ENABLE_PIN             6    //
#define OPENED_LIMIT_PIN       7    //  
#define CLOSED_LIMIT_PIN       8
#define OPEN_PIN               11   //
#define CLOSE_PIN              12

int moveAwayFromLimit = 200;
boolean bStartPressed = false; 
boolean cStartPressed = false;
#define STEPS 313
#define STARTING_INDEX 2

int delays[STEPS];
int iCount = 0;

enum ProgramState { IDLE, OPENING, OPENED, CLOSING };
ProgramState programState = IDLE;
  
  void constantAccel(int iDelay) 
{
    int OPENED_LIMIT_PIN_state = digitalRead(OPENED_LIMIT_PIN);
    if (OPENED_LIMIT_PIN_state == LOW)
    {
      digitalWrite(STEP_PIN, HIGH);
      delayMicroseconds( iDelay );
      digitalWrite(STEP_PIN, LOW);
      delayMicroseconds( iDelay );
    }
    else //hit limmit switch
    {
       int i;
 //----------------------------------------debug start
      Serial.println("hit open limit switch");  
 //----------------------------------------debug end 
       digitalWrite(LED_BUILTIN, HIGH);  
       digitalWrite(ENABLE_PIN, LOW);  
       digitalWrite(DIR_PIN, HIGH); // reverse direction 
       for(i = 0; i < moveAwayFromLimit; i++)
  
       {  
         digitalWrite(STEP_PIN, HIGH);
         delayMicroseconds( 1000 );
         digitalWrite(STEP_PIN, LOW);
         delayMicroseconds( 1000 );
       }
       programState = OPENED;
       digitalWrite(ENABLE_PIN, HIGH);   
       digitalWrite(LED_BUILTIN, LOW);
       iCount = 0; 
       Serial.println("Stoped after reverseing off limit");
    }

}
 
void constantAccel_2(int iDelay)
{   
     int CLOSED_LIMIT_PIN_state = digitalRead(CLOSED_LIMIT_PIN);
    if (CLOSED_LIMIT_PIN_state == LOW)
    {
      digitalWrite(STEP_PIN, HIGH);
      delayMicroseconds( iDelay );
      digitalWrite(STEP_PIN, LOW);
      delayMicroseconds( iDelay );
    }
    else //hit limmit switch
    {
       int i;
 //----------------------------------------debug start
      Serial.println("hit closeed limit switch");  
 //----------------------------------------debug end 
       digitalWrite(LED_BUILTIN, HIGH);  
       digitalWrite(ENABLE_PIN, LOW);  
       digitalWrite(DIR_PIN, LOW); // reverse direction 
       for(i = 0; i < moveAwayFromLimit; i++)
  
       {  
         digitalWrite(STEP_PIN, HIGH);
         delayMicroseconds( 1000 );
         digitalWrite(STEP_PIN, LOW);
         delayMicroseconds( 1000 );
       }
       programState = IDLE;
       digitalWrite(ENABLE_PIN, HIGH);   
       digitalWrite(LED_BUILTIN, LOW);
       iCount = 0; 
       Serial.println("Stoped after reverseing off limit");
    }
}

  


void setup() {
  pinMode(STEP_PIN,   OUTPUT);              //
  pinMode(DIR_PIN,    OUTPUT);              //
  pinMode(ENABLE_PIN, OUTPUT);              //              
  pinMode(OPEN_PIN, INPUT);          // changed from INPUT_PULLUP for test
  pinMode(CLOSE_PIN, INPUT);         //
  pinMode(OPENED_LIMIT_PIN, INPUT);  // changed to INPUT
  pinMode(CLOSED_LIMIT_PIN, INPUT);  //
  pinMode(LED_BUILTIN, OUTPUT);             //
  digitalWrite(ENABLE_PIN, HIGH);           //

  Serial.begin(9600);
  
  

  float angle = 1;
  float accel = 0.01;
  float c0 = 2000 * sqrt( 2 * angle / accel ) * 0.67703;
  float lastDelay = 0;
  int highSpeed = 800;
  
   for (int i = 0; i < STEPS; i++) 
  {
    float d = c0;
    if ( i > 0 )
      d = lastDelay - (2 * lastDelay) / (4 * i + 1);
//      d = lastDelay - (2 * lastDelay) / (i + 1);
    if ( d < highSpeed )
      d = highSpeed;
    
    if( i > STARTING_INDEX) 
      delays[i-STARTING_INDEX-1] = d;
  //  delays[STEPS-1-i] = d;
    lastDelay = d;

  }
}


void forward() {
    digitalWrite(LED_BUILTIN, HIGH);  
    digitalWrite(ENABLE_PIN, LOW);  
    digitalWrite(DIR_PIN, LOW); // forward direction
}

void reverse() {
    digitalWrite(LED_BUILTIN, HIGH);  
    digitalWrite(ENABLE_PIN, LOW);  
    digitalWrite(DIR_PIN, HIGH); // forward direction
}

void loop() {
  int open = digitalRead(OPEN_PIN);
  int close = digitalRead(CLOSE_PIN);
  
  switch(programState) {
    case IDLE:

    if ( open == LOW) {
        programState = OPENING;
        forward();
        Serial.println("Opening...");
    }
    break;
    case OPENING:
      if (iCount < STEPS-STARTING_INDEX-1)
        {
           constantAccel(delays[iCount]);
           iCount = iCount + 1;
        }
      break;
    case OPENED:
      if (close == LOW) {
        programState = CLOSING;
        reverse();
        Serial.println("Closing...");      
      }
      break;
    case CLOSING:
      
      if (iCount < STEPS-STARTING_INDEX-1)
      {
        constantAccel_2(delays[iCount]);
        iCount = iCount + 1;
      }
      
      break;
    default:
      break;
  }
  
  delay(50);
}