Arduino 具有相同执行时间的多个BallsCW链接步进电机的并行访问

我正在尝试编写一个3轴移动步进机连杆滚珠丝杠设置，我的输入是xdistance to move、ydistance to move、z distance to move、持续时间和执行循环时间。我需要将3轴移动到一起，使其具有相同的开始时间和停止时间

我已经写了下面的代码，我的

X移动距离=40毫米

Y移动距离=10毫米

z移动距离=5mm

持续时间=4秒

执行的循环次数=2

我面临的一个问题是，所有三个步进电机的启动和停止时间都相同，而移动距离却各不相同。但根据我的代码，它应该同时启动和停止，如果距离不同，移动速度也会相应变化

int t = 4;
int xDist = 40;
const int xPitch = 5;
const int xStepsPerRevolution = 200;
float x_STEP_PERIOD_MS, x_STEP_PERIOD_MS1;
int x_STEPS_NOS = 0;
int x_STEPS_NOS1 = 0;
const int x_STEP_PIN = 5;
const int x_DIR_PIN = 3;
unsigned long xNextStepTime, xNextStepTime1;
volatile int xflag = 1;
volatile int xbackward_finished = 0;
int yDist = 10;
const int yPitch = 5;
const int yStepsPerRevolution = 200;
float y_STEP_PERIOD_MS, y_STEP_PERIOD_MS1;
int y_STEPS_NOS = 0;
int y_STEPS_NOS1 = 0;
const int y_STEP_PIN = 9;
const int y_DIR_PIN = 7;
unsigned long yNextStepTime, yNextStepTime1;
volatile int yflag = 1;
volatile int ybackward_finished = 0;
int zDist = 5;
const int zPitch = 10;
const int zStepsPerRevolution = 400;
float z_STEP_PERIOD_MS, z_STEP_PERIOD_MS1;
int z_STEPS_NOS = 0;
int z_STEPS_NOS1 = 0;
const int z_STEP_PIN = 11;
const int z_DIR_PIN = 13;
unsigned long zNextStepTime, zNextStepTime1;
volatile int zflag = 1;
volatile int zbackward_finished = 0;
int no_of_times=2;
void setup()
{
  pinMode(x_STEP_PIN, OUTPUT);
  digitalWrite(x_STEP_PIN, LOW);
  pinMode(x_DIR_PIN, OUTPUT);
  pinMode(A1, INPUT_PULLUP);
  pinMode(A2, INPUT_PULLUP);
  xNextStepTime = millis();
  xNextStepTime1 = millis();
  pinMode(y_STEP_PIN, OUTPUT);
  digitalWrite(y_STEP_PIN, LOW);
  pinMode(y_DIR_PIN, OUTPUT);
  pinMode(A3, INPUT_PULLUP);
  pinMode(A4, INPUT_PULLUP);
  yNextStepTime = millis();
  yNextStepTime1 = millis();
  pinMode(z_STEP_PIN, OUTPUT);
  digitalWrite(z_STEP_PIN, LOW);
  pinMode(z_DIR_PIN, OUTPUT);
  pinMode(A5, INPUT_PULLUP);
  pinMode(A6, INPUT_PULLUP);
  zNextStepTime = millis();
  zNextStepTime1 = millis();
  Serial.begin(9600);
}
void moveforward()
{
  x_STEP_PERIOD_MS = ((1000 * t) / ((xStepsPerRevolution / xPitch) * xDist));
  unsigned long xtime0 = millis();
  if ( (xflag == 1) && ((long)(xNextStepTime - xtime0) < 0) && (x_STEPS_NOS < ((xStepsPerRevolution / xPitch) * xDist)) && ((digitalRead(A1)*digitalRead(A2)) == 1))
  {{
      digitalWrite(x_DIR_PIN, LOW);
      xNextStepTime = xtime0 + x_STEP_PERIOD_MS;
      digitalWrite(x_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(x_STEP_PIN, LOW);
      x_STEPS_NOS = x_STEPS_NOS + 1;
    }
    if (((long)(xNextStepTime - xtime0) == 0) || (x_STEPS_NOS == ((xStepsPerRevolution / xPitch) * xDist)))
    {
      xflag = 0; xtime0 = 0; x_STEPS_NOS = 0;
    }
  }

   y_STEP_PERIOD_MS = ((1000 * t) / ((yStepsPerRevolution / yPitch) * yDist));
  unsigned long ytime0 = millis();
  if ( (yflag == 1) && ((long)(yNextStepTime - ytime0) < 0) && (y_STEPS_NOS < ((yStepsPerRevolution / yPitch) * yDist)) && ((digitalRead(A3)*digitalRead(A4)) == 1))
  {{
      digitalWrite(y_DIR_PIN, HIGH);
      yNextStepTime = ytime0 + y_STEP_PERIOD_MS;
      digitalWrite(y_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(y_STEP_PIN, LOW);
      y_STEPS_NOS = y_STEPS_NOS + 1;
    }
    if (((long)(yNextStepTime - ytime0) == 0) || (y_STEPS_NOS == ((yStepsPerRevolution / yPitch) * yDist)))
    {
      yflag = 0; ytime0 = 0; y_STEPS_NOS = 0;
    }
  }

   z_STEP_PERIOD_MS = ((1000 * t) / ((zStepsPerRevolution / zPitch) * zDist));
  unsigned long ztime0 = millis();
  if ( (zflag == 1) && ((long)(zNextStepTime - ztime0) < 0) && (z_STEPS_NOS < ((zStepsPerRevolution / zPitch) * zDist)) && ((digitalRead(A5)*digitalRead(A6)) == 1))
  {{
      digitalWrite(z_DIR_PIN, LOW);
      zNextStepTime = ztime0 + z_STEP_PERIOD_MS;
      digitalWrite(z_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(z_STEP_PIN, LOW);
      z_STEPS_NOS = z_STEPS_NOS + 1;
    }
    if (((long)(zNextStepTime - ztime0) == 0) || (z_STEPS_NOS == ((zStepsPerRevolution / zPitch) * zDist)))
    {
      zflag = 0; ztime0 = 0; z_STEPS_NOS = 0;
    }
  }
}
void movebackward()
{
  x_STEP_PERIOD_MS1 = ((1000 * t) / ((xStepsPerRevolution / xPitch) * xDist));
  unsigned long xtime1 = millis();
  if ( (xflag == 0) && ((long)(xNextStepTime1 - xtime1) < 0) && (x_STEPS_NOS1 < ((xStepsPerRevolution / xPitch) * xDist)) && ((digitalRead(A1)*digitalRead(A2)) == 1))
  {{
      digitalWrite(x_DIR_PIN, HIGH);
      xNextStepTime1 = xtime1 + x_STEP_PERIOD_MS1;
      digitalWrite(x_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(x_STEP_PIN, LOW);
      x_STEPS_NOS1 = x_STEPS_NOS1 + 1;
    }
    if (((long)(xNextStepTime1 - xtime1) == 0) || (x_STEPS_NOS1 == ((xStepsPerRevolution / xPitch) * xDist)))
    {
      xflag = 1; xtime1 = 0; x_STEPS_NOS1 = 0;
      xbackward_finished = xbackward_finished + 1;
    }
  }

    y_STEP_PERIOD_MS1 = ((1000 * t) / ((yStepsPerRevolution / yPitch) * yDist));
  unsigned long ytime1 = millis();
  if ( (yflag == 0) && ((long)(yNextStepTime1 - ytime1) < 0) && (y_STEPS_NOS1 < ((yStepsPerRevolution / yPitch) * yDist)) && ((digitalRead(A3)*digitalRead(A4)) == 1))
  {{
      digitalWrite(y_DIR_PIN, LOW);
      yNextStepTime1 = ytime1 + y_STEP_PERIOD_MS1;
      digitalWrite(y_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(y_STEP_PIN, LOW);
      y_STEPS_NOS1 = y_STEPS_NOS1 + 1;
    }
    if (((long)(yNextStepTime1 - ytime1) == 0) || (y_STEPS_NOS1 == ((yStepsPerRevolution / yPitch) * yDist)))
    {
      yflag = 1; ytime1 = 0; y_STEPS_NOS1 = 0;
      ybackward_finished = ybackward_finished + 1;
    }
  }

     z_STEP_PERIOD_MS1 = ((1000 * t) / ((zStepsPerRevolution / zPitch) * zDist));
  unsigned long ztime1 = millis();
  if ( (zflag == 0) && ((long)(zNextStepTime1 - ztime1) < 0) && (z_STEPS_NOS1 < ((zStepsPerRevolution / zPitch) * zDist)) && ((digitalRead(A5)*digitalRead(A6)) == 1))
  {{
      digitalWrite(z_DIR_PIN, HIGH);
      zNextStepTime1 = ztime1 + z_STEP_PERIOD_MS1;
      digitalWrite(z_STEP_PIN, HIGH);
      delayMicroseconds(2);
      digitalWrite(z_STEP_PIN, LOW);
      z_STEPS_NOS1 = z_STEPS_NOS1 + 1;
    }
    if (((long)(zNextStepTime1 - ztime1) == 0) || (z_STEPS_NOS1 == ((zStepsPerRevolution / zPitch) * zDist)))
    {
      zflag = 1; ztime1 = 0; z_STEPS_NOS1 = 0;
      zbackward_finished = zbackward_finished + 1;
    }
  }
}
void loop()
{
  moveforward();
  movebackward();
  if (xbackward_finished == no_of_times) {
    while (1) {

    }
  }
}

int t=4；
int-xDist=40；
常数int xPitch=5；
常数int xStepsPerRevolution=200；
浮动x_步进周期_MS，x_步进周期_MS1；
int x_步数=0；
int x_步数_NOS1=0；
常数int x_步进_PIN=5；
常数int x_DIR_PIN=3；
无符号长xNextStepTime，xNextStepTime1；
volatile int xflag=1；
volatile int xbackward_finished=0；
int-yDist=10；
常数int-yPitch=5；
常数int=200；
浮动y步进周期，y步进周期1；
int y_步数=0；
int y_步数_NOS1=0；
const int y_STEP_PIN=9；
const int y_DIR_PIN=7；
无符号长yNextStepTime，yNextStepTime1；
volatile int yflag=1；
volatile int ybackward_finished=0；
int-zDist=5；
常数int zPitch=10；
常数int zStepsPerRevolution=400；
浮动z_步长周期，z_步长周期1；
int z_步数=0；
int z_步数_NOS1=0；
const int z_STEP_PIN=11；
const int z_DIR_PIN=13；
无符号长zNextStepTime，zNextStepTime1；
易失性int-zflag=1；
volatile int zbackward_finished=0；
int no_of_times=2；
无效设置（）
{
引脚模式（x_步进引脚，输出）；
数字写入（x_步进_引脚，低电平）；
pinMode（x_DIR_PIN，输出）；
引脚模式（A1，输入\上拉）；
引脚模式（A2，输入\上拉）；
xNextStepTime=millis（）；
xNextStepTime1=millis（）；
引脚模式（y_步进引脚，输出）；
数字写入（y_步进_引脚，低电平）；
pinMode（y_DIR_PIN，输出）；
引脚模式（A3，输入\上拉）；
pinMode（A4，输入\上拉）；
yNextStepTime=millis（）；
yNextStepTime1=millis（）；
引脚模式（z_步进引脚，输出）；
数字写入（z_步进_引脚，低电平）；
pinMode（z_DIR_PIN，输出）；
引脚模式（A5，输入\上拉）；
引脚模式（A6，输入\上拉）；
zNextStepTime=millis（）；
zNextStepTime1=millis（）；
Serial.begin（9600）；
}
void向前移动（）
{
x步进周期MS=（（1000*t）/（（xStepsPerRevolution/xPitch）*xDist））；
无符号长xtime0=millis（）；
如果（（xflag==1）和（（long）（xNextStepTime-xtime0）<0）和（（xStepsPerRevolution/xPitch）*xDist））和（（digitalRead（A1）*digitalRead（A2））==1））
{{
数字写入（x_DIR_PIN，低电平）；
xNextStepTime=xtime0+x_步长周期_MS；
数字写入（x_步进_引脚，高）；
延迟微秒（2）；
数字写入（x_步进_引脚，低电平）；
x_步数=x_步数+1；
}
如果（（长）（xNextStepTime-xtime0）=0）| |（x_步骤数==（（xStepsPerRevolution/xPitch）*xDist）））
{
xflag=0；xtime0=0；x步数=0；
}
}
y步进周期μMS=（（1000*t）/（（y步进/y步进）*yDist））；
无符号长ytime0=毫秒（）；
如果（（yflag==1）和（（long）（yNextStepTime-ytime0）<0）和（（yStepPerEvolution/yPitch）*yDist）和（（digitalRead（A3）*digitalRead（A4））==1））
{{
数字写入（y_DIR_PIN，高）；
yNextStepTime=ytime0+y\u步长\u周期\u毫秒；
数字写入（y_步进_引脚，高）；
延迟微秒（2）；
数字写入（y_步进_引脚，低电平）；
y_步数=y_步数+1；
}
if（（（长）（yNextStepTime-ytime0）=0）| | |（y|u步数==（（ystepperrevolution/yPitch）*yDist）））
{
yflag=0；ytime0=0；y_步数=0；
}
}
z_阶跃周期_MS=（（1000*t）/（（zStepsPerRevolution/zPitch）*zDist））；
无符号长ztime0=millis（）；
如果（（zflag==1）和（（long）（zNextStepTime-ztime0）<0）和（（zStepsPerRevolution/zPitch）*zDist））和（（digitalRead（A5）*digitalRead（A6））==1））
{{
数字写入（z_DIR_PIN，低电平）；
zNextStepTime=ztime0+z_步长周期毫秒；
数字写入（z_步进_引脚，高）；
延迟微秒（2）；
数字写入（z_步进_引脚，低电平）；
z_步数=z_步数+1；
}
如果（（长）（zNextStepTime-ztime0）=0）| |（z|u步数==（（zStepsPerRevolution/zPitch）*zDist）））
{
zflag=0；ztime0=0；z_步数=0；
}
}
}
void movebackward（）
{
x_阶跃周期_MS1=（（1000*t）/（（xStepsPerRevolution/xPitch）*xDist））；
无符号长xtime1=millis（）；
如果（（xflag==0）和（（long）（xNextStepTime1-xtime1）<0）和（（xStepsPerRevolution/xPitch）*xDist））&（（digitalRead（A1）*digitalRead（A2））=1））
{{
数字写入（x_DIR_PIN，高）；
xNextStepTime1=xtime1+x_步骤_周期_MS1；
数字写入（x_步进_引脚，高）；
延迟微秒（2）；
数字写入（x_步进_引脚，低电平）；
x_步数_NOS1=x_步数_NOS1+1；
}
如果（（长）（xNextStepTime1-xtime1）=0）| |（x_步骤_NOS1==（（xStepsPerRevolution/xPitch）*xDist）））
{
xflag=1；xtime1=0；x_步数_NOS1=0；
xbackward_finished=xbackward_finished+1；
}
}
y_阶跃周期_MS1=（（1000*t）/（（y阶跃/y阶跃）*yDist））；
无符号长ytime1=毫秒（）；
如果（（yflag==0）和（（long）（yNextStepTime1-ytime1）<0）和（（yStepPerEvolution/yPitch）*yDist））和（（digitalRead（A3）*digitalRead（A4））==1））
{{
数字写入（y_DIR_PIN，低电平）；
yNextStepTime1=ytime1+y\u步长\u周期\u MS1；
数字写入（y_步进_引脚，高）；
延迟微秒（2）；
数字写入（y_步进_引脚，低电平）；
y_步数_NOS1=y_步数_NOS1+1；
}
if（（（长）（yNextStepTime1-ytime1）=0）| |（y|u STEPS_NOS1==（（ystepperrevolution/yPitch）*yDist）））