Flute cutting code

// big lathe using Probotix controllers and motors. LOW = forward & clockwise
//*************************************
//these are the variables to change for the part.
float spiralLen = 1.75;  //length of the spiral on part being cut
float pitch = .022;     //pitch -- revs per inch on part being cut
int rpm = 115; //tweak as needed for performance
int flutes = 8;
//**************************************

//motor setup 
int spindleMotorRevs = 200; //steps on the spindle motor
int feedMotorRevs = 200;     //steps on the feed motor
int spindleMSteps = 4; //microstepping for the spindle motor
int feedMSteps = 8; //microstepping for the feed motor
int spindleRev; //actual movement on the machine1
int feedRev;
float spindleGearRatio = 4; //gear ratio for spindle == 4:1 reduction
float feedGearRatio = 1; //gear ratio for feed
float feedStepsPerRev; // feed steps per spindle rev
long spindleLoc = 0;
long feedLoc = 0;
long fluteGap = 0;

//thread setup
int leadPitch = 5;  //pitch on the feedscrew. don't change without changing hardware
float  pitchRatio;  //ration of the hardware pitch to the part pitch
float motorRatio;
int uSDelay;
int dir;

void setup() {
  Serial.begin(9600);           // set up Serial library at 9600 bps
  pinMode(3, OUTPUT);  //feed dir
  pinMode(4, OUTPUT);  //feed step
  pinMode(5, OUTPUT);  //spindle dir
  pinMode(6, OUTPUT);  //spindle step
  spindleRev = spindleMotorRevs * spindleMSteps * spindleGearRatio; // calc true spindleRev
  feedRev = feedMotorRevs * feedMSteps * feedGearRatio;  //calc true feedrev
  pitchRatio = leadPitch / pitch;
  motorRatio = float(feedRev) / float(spindleRev);
  feedStepsPerRev = motorRatio * pitchRatio * spindleRev;


  //Serial.println(feedStepsPerRev);

  uSDelay = getDelay(rpm, feedRev);

}

void loop() {



  int start = 0; //start command
  long i = 0;
  long y = 0;
  long z;
  long h = 1;
  long j;
  int m;

  int quit = 0;
  long lastDisplay;
  float spindleAngle;
  float feedInches;
  float spindleAngleRatio;
  float feedInchesRatio;


  z = calcLen();

  fluteGap = getFluteSteps();

  h = 1;
  if (Serial.available() > 0) {
    start = Serial.read();
  }

  delay(100);
  if(start == 48 + 1) { 
    for(j=0; j < flutes; j++) {

      while (h <= z) {
        digitalWrite(3, LOW); //LOW IS away from headstock (forward)
        digitalWrite(5, HIGH); //HIGH IS clockwise
        y = calcY(i);
        h = h + y;
        i = i + 1;

        digitalWrite(6, LOW);
        digitalWrite(6, HIGH);
        //Serial.println(y);
        if(y>0) {  // if feed  steps > 1, loop through until next feed step
          for(int x = 1; x <= y; x++){
            digitalWrite(4, LOW);
            digitalWrite(4, HIGH);
            //Serial.println(y);
            feedLoc = feedLoc + 1;
            if(x == y) {
              break;
            }
            delayMicroseconds(uSDelay);
          }
        }
        spindleLoc = spindleLoc + 1;
        if(spindleLoc >= spindleRev) {
          spindleLoc = spindleLoc - spindleRev;
        }
        //Serial.println(spindleLoc);
        //Serial.println(spindleRev);
        //spindleAngle = getSpindleAngle(spindleLoc);
        delayMicroseconds(uSDelay);
        if (Serial.available() > 0) {
          quit = Serial.read();
        }
        if(quit == 48 + 2) {
          break;
        }



      }
      delay(100);
      for(m = 0; m < spindleRev/360;m++){
        digitalWrite(6, LOW);
        digitalWrite(6, HIGH);
        delay(3);
        spindleLoc = spindleLoc + 1;
        if(spindleLoc >= spindleRev) {
          spindleLoc = spindleLoc - spindleRev;
        }
      }
      delay(100);
      while (h >= 0) {
        digitalWrite(3, HIGH); //LOW IS away from headstock (forward)
        digitalWrite(5, LOW); //HIGH IS clockwise
        y = calcY(i);
        h = h - y;
        i = i - 1;

        digitalWrite(6, LOW);
        digitalWrite(6, HIGH);
        if(y>0) {  // if feed  steps > 1, loop through until next feed step
          for(int x = 1; x <= y; x++){
            digitalWrite(4, LOW);
            digitalWrite(4, HIGH);

            feedLoc = feedLoc - 1;
            if(x == y) {
              break;
            }
            delayMicroseconds(uSDelay);
          }
        }
        spindleLoc = spindleLoc - 1;
        if(spindleLoc <= 0) {
          spindleLoc = spindleLoc + spindleRev;
        }
        delayMicroseconds(uSDelay);

        if (Serial.available() > 0) {
          quit = Serial.read();
        }
        if(quit == 48 + 2) {
          break;
        }

      }
      delay(100);
      for(m = spindleRev/360; m > 0;m--){
        digitalWrite(6, LOW);
        digitalWrite(6, HIGH);
        delay(5);
        spindleLoc = spindleLoc - 1;
        if(spindleLoc <= 0) {
          spindleLoc = spindleLoc + spindleRev;
        }
      }
      delay(100);
      for(m = 0; m <= fluteGap; m++) {
        digitalWrite(6, LOW);
        digitalWrite(6, HIGH);
        delay(3);
        spindleLoc = spindleLoc - 1;
        if(spindleLoc <= 0) {
          spindleLoc = spindleLoc + spindleRev;
        }
      }
      delay(100);
    }
    start = 0;
  }

  if(start == 48 + 3) {
    //zeroFeed(31200);
    //feedLoc = zeroFeed(-112000);
    feedLoc = zeroFeed(feedLoc);
  }


  if(start == 48 + 4) {
    spindleLoc = zeroSpindle(spindleLoc);

  }


  //sleazy hack to rotate spindle rots tiemes
  if(start == 48 + 5) {
    int rots = 10; //number of rotations
    digitalWrite(5, LOW);
    for(i = 0; i < (rots * spindleRev); i++){
      digitalWrite(6, LOW);
      digitalWrite(6, HIGH);
      delay(5);
    }
  }
}
//end of loop

long calcLen(){
  long x;
  x = spiralLen * leadPitch * feedRev;
  return x;
}



int calcY(long v){ // calculate feed step
  float r;
  long m;
  long j;
  float k;
  r = floor(v * feedStepsPerRev / spindleRev);
  k = floor((v-1) * feedStepsPerRev / spindleRev);
  m = floor(r - k);
  return m;

}


int getDelay(float RPM, float motorSteps) {
  float uS = 0;
  uS = 1000000/((RPM/60) * motorSteps);
  return floor(uS);
}

float getFeedInches(long loc) {
  float m;
  float j;
  m = feedRev * leadPitch;
  //Serial.println(loc);
  j = float(loc) / m;
  return j;
}

float getSpindleAngle(long loc) {
  float m;
  float j;
  if(loc == 0) {
    return loc;
  }
  m = 360 / float(spindleRev);
  j = float(loc) * m;
  return j;
}

long getFluteSteps() {
  float fSteps;
  fSteps =  spindleRev / flutes;
  return long(fSteps);
}

long zeroFeed(long loc) {
  long i;
  if(loc ==0) {
    return loc;
  }
  if(loc > 0) {
    digitalWrite(3, HIGH);
    for(i = loc; i >0; i--){  
      digitalWrite(4, LOW);
      digitalWrite(4, HIGH);
      delayMicroseconds(175);
    }
  }
  else if(loc < 0) {
    digitalWrite(3, LOW);
    for(i = loc; i < 0; i++){  
      digitalWrite(4, LOW);
      digitalWrite(4, HIGH);
      delayMicroseconds(175);
    }
  }
  return i;
} 

int zeroSpindle(int loc) {
  long i;
  if(loc == 0) {
    return loc;
  }
  digitalWrite(5, LOW);
  for(i = loc; i > 0; i--){
    digitalWrite(6, LOW);
    digitalWrite(6, HIGH);
    delay(3);
  }
  return i;
}