Arduino：循环中同时只有3件事

我通过AccelStepper库得到了运行14个步进器的代码。 但我只想同时运行3台步进电机。 如果需要使用4个（或更多）步进电机，则第4个步进电机应等待其他3个步进电机中的一个完成。 方法：在“空闲插槽”可用时启动步进电机。 我该怎么做

这是我的密码：

  #include <Max3421e.h>
  #include <Usb.h>
  #include <AndroidAccessory.h>
  #include <AccelStepper.h>

  #define VALUE_OFF 0x0
  #define VALUE_ON 0x1
  #define COMMAND_DRINK 0x2
  #define COMMAND_LED 0x3

  AndroidAccessory acc("Manufacturer",
                 "Model",
                 "Description",
                 "1.0",
                 "http://nichtsda.com",
                 "0000000012345678");


  //pin definitions.  must be PWM-capable pins!
  const int redPin = 2;
  const int greenPin = 3;
  const int bluePin = 4;


  AccelStepper stepper1   (AccelStepper::DRIVER, 23, 12);
  AccelStepper stepper2   (AccelStepper::DRIVER, 27, 11);
  AccelStepper stepper3   (AccelStepper::DRIVER, 31, 11);
  AccelStepper stepper4   (AccelStepper::DRIVER, 35, 11);
  AccelStepper stepper5   (AccelStepper::DRIVER, 39, 11);
  AccelStepper stepper6   (AccelStepper::DRIVER, 43, 11);
  AccelStepper stepper7   (AccelStepper::DRIVER, 47, 11);
  AccelStepper stepper8   (AccelStepper::DRIVER, 51, 11);
  AccelStepper stepper9   (AccelStepper::DRIVER, 24, 11);
  AccelStepper stepper10  (AccelStepper::DRIVER, 28, 11);
  AccelStepper stepper11  (AccelStepper::DRIVER, 32, 11);
  AccelStepper stepper12  (AccelStepper::DRIVER, 36, 11);
  AccelStepper stepper13  (AccelStepper::DRIVER, 40, 11);
  AccelStepper stepper14  (AccelStepper::DRIVER, 44, 11);



  //int stepPin[16]={23,27,31,35,39,43,47,51,24,28,32,36,40,44,48,52};
  int multiplikator = 60000;
  int MengeZutat[16];


  const int max_red = 255;
  const int max_green = 255;
  const int max_blue = 200;

  byte colors[3] = {0, 0, 0}; //array to store led brightness values
  byte rcvmsg[16];



void setup()
{

//set all three of our led pins to output
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
Serial.begin(115200);
acc.powerOn();


stepper1.setMaxSpeed(1800.0);
stepper1.setAcceleration(1000.0);

stepper2.setMaxSpeed(1100.0);
stepper2.setAcceleration(1000.0);

stepper3.setMaxSpeed(1800.0);
stepper3.setAcceleration(1000.0);


stepper4.setMaxSpeed(1800.0);
stepper4.setAcceleration(1000.0);

stepper5.setMaxSpeed(1800.0);
stepper5.setAcceleration(1000.0);

stepper6.setMaxSpeed(1800.0);
stepper6.setAcceleration(1000.0);

stepper7.setMaxSpeed(1800.0);
stepper7.setAcceleration(1000.0);

stepper8.setMaxSpeed(1800.0);
stepper8.setAcceleration(1000.0);

stepper9.setMaxSpeed(1800.0);
stepper9.setAcceleration(1000.0);

stepper10.setMaxSpeed(1800.0);
stepper10.setAcceleration(1000.0);

stepper11.setMaxSpeed(1800.0);
stepper11.setAcceleration(1000.0);

stepper12.setMaxSpeed(1800.0);
stepper12.setAcceleration(1000.0);

stepper13.setMaxSpeed(1800.0);
stepper13.setAcceleration(1000.0);

stepper14.setMaxSpeed(1800.0);
stepper14.setAcceleration(1000.0);

}



void loop()
{

if (acc.isConnected()) {
acc.read(rcvmsg, sizeof(rcvmsg), 1);






 if (rcvmsg[14] == COMMAND_LED ) {
  byte value = rcvmsg[15];
  if (value == VALUE_ON) {
    colors[0] = rcvmsg[0] + 128;
    colors[1] = rcvmsg[1] + 128;
    colors[2] = rcvmsg[2] + 128;
    analogWrite(redPin, map(colors[0], 0, 255, 0, max_red));
    analogWrite(greenPin, map(colors[1], 0, 255, 0, max_green));
    analogWrite(bluePin, map(colors[2], 0, 255, 0, max_blue));
  }
  else if (value = VALUE_OFF) {
    colors[0] = 0;
    colors[1] = 0;
    colors[2] = 0;
    analogWrite(redPin, map(colors[0], 0, 255, 0, max_red));
    analogWrite(greenPin, map(colors[1], 0, 255, 0, max_green));
    analogWrite(bluePin, map(colors[2], 0, 255, 0, max_blue));
  }
 }



 if (rcvmsg[14] == COMMAND_DRINK ) {
  byte value = rcvmsg[15];
  if (value == VALUE_ON) {

    //int sleepPin[16]={25,29,33,37,41,45,49,53,22,26,30,34,38,42,46,50};


    stepper1.move(rcvmsg[0]*multiplikator);
    stepper1.setEnablePin(25);

    stepper2.move(rcvmsg[1]*multiplikator);
    stepper2.setEnablePin(29);

    stepper3.move(rcvmsg[2]*multiplikator);
    stepper3.setEnablePin(33);

    stepper4.move(rcvmsg[3]*multiplikator);
    stepper4.setEnablePin(25);

    stepper5.move(rcvmsg[4]*multiplikator);
    stepper5.setEnablePin(37);

    stepper6.move(rcvmsg[5]*multiplikator);
    stepper6.setEnablePin(41);

    stepper7.move(rcvmsg[6]*multiplikator);
    stepper7.setEnablePin(45);

    stepper8.move(rcvmsg[7]*multiplikator);
    stepper8.setEnablePin(49);

    stepper9.move(rcvmsg[8]*multiplikator);
    stepper9.setEnablePin(53);

    stepper10.move(rcvmsg[9]*multiplikator);
    stepper10.setEnablePin(22);

    stepper11.move(rcvmsg[10]*multiplikator);
    stepper11.setEnablePin(26);

    stepper12.move(rcvmsg[11]*multiplikator);
    stepper12.setEnablePin(30);

    stepper13.move(rcvmsg[12]*multiplikator);
    stepper13.setEnablePin(34);

    stepper14.move(rcvmsg[13]*multiplikator);
    stepper14.setEnablePin(38);

  }
  else if (value == VALUE_OFF ) {



    stepper1.run();
    if (stepper1.isRunning() == false) {
      stepper1.disableOutputs();
    }

    stepper2.run();
    if (stepper2.isRunning() == false) {
      stepper2.disableOutputs();
    }


    stepper3.run();
    if (stepper3.isRunning() == false) {
      stepper3.disableOutputs();
    }

    stepper4.run();
    if (stepper4.isRunning() == false) {
      stepper4.disableOutputs();
    }

    stepper5.run();
    if (stepper5.isRunning() == false) {
      stepper5.disableOutputs();
    }

    stepper6.run();
    if (stepper6.isRunning() == false) {
      stepper6.disableOutputs();
    }

    stepper7.run();
    if (stepper7.isRunning() == false) {
      stepper7.disableOutputs();
    }

    stepper8.run();
    if (stepper8.isRunning() == false) {
      stepper8.disableOutputs();
    }


    stepper9.run();
    if (stepper9.isRunning() == false) {
      stepper9.disableOutputs();
    }

    stepper10.run();
    if (stepper10.isRunning() == false) {
      stepper10.disableOutputs();
    }

    stepper11.run();
    if (stepper11.isRunning() == false) {
      stepper11.disableOutputs();
    }

    stepper12.run();
    if (stepper12.isRunning() == false) {
      stepper12.disableOutputs();
    }


    stepper13.run();
    if (stepper13.isRunning() == false) {
      stepper13.disableOutputs();
    }

    stepper14.run();
    if (stepper14.isRunning() == false) {
      stepper14.disableOutputs();
    }




  }
}



}
}

#包括
#包括
#包括
#包括
#定义值_OFF 0x0
#在0x1上定义值_
#定义命令0x2
#定义命令指示灯0x3
AndroidAccessory acc（“制造商”，
“模型”，
“说明”，
"1.0",
"http://nichtsda.com",
"0000000012345678");
//引脚定义。必须是PWM功能引脚！
常数int redPin=2；
常数int greenPin=3；
常数int bluePin=4；
AccelStepper-stepper1（AccelStepper:：DRIVER，23,12）；
AccelStepper-stepper2（AccelStepper:：DRIVER，27,11）；
AccelStepper stepper3（AccelStepper:：DRIVER，31,11）；
加速步进器步进器4（加速步进器：：驱动器，35，11）；
AccelStepper-stepper5（AccelStepper:：DRIVER，39，11）；
加速步进器步进器6（加速步进器：：驱动程序，43，11）；
AccelStepper步进器7（AccelStepper:：DRIVER，47，11）；
加速步进器步进器8（加速步进器：：驱动器，51，11）；
加速步进器步进器9（加速步进器：：驱动程序，24，11）；
AccelStepper-stepper10（AccelStepper:：DRIVER，28,11）；
加速步进器步进11（加速步进器：：驱动程序，32，11）；
加速步进器步进12（加速步进器：：驱动程序，36，11）；
加速步进器步进13（加速步进器：：驱动程序，40，11）；
AccelStepper步进器14（AccelStepper:：DRIVER，44，11）；
//int stepPin[16]={23,27,31,35,39,43,47,51,24,28,32,36,40,44,48,52}；
整数倍频器=60000；
int MengeZutat[16]；
常数int max_red=255；
常量int max_green=255；
常数int max_blue=200；
字节颜色[3]={0,0,0}//用于存储led亮度值的阵列
字节rcvmsg[16]；
无效设置（）
{
//将所有三个led引脚设置为输出
引脚模式（红色引脚，输出）；
引脚模式（绿色引脚，输出）；
引脚模式（蓝引脚，输出）；
序列号开始（115200）；
acc.powerOn（）；
步进1.设置最大速度（1800.0）；
步进1.设定加速度（1000.0）；
步进2.setMaxSpeed（1100.0）；
步进2.设定加速度（1000.0）；
步进3.设置最大速度（1800.0）；
步进3.设定加速度（1000.0）；
步进电机4.setMaxSpeed（1800.0）；
步进4.设定加速度（1000.0）；
步进5.设定最大速度（1800.0）；
步进5.设定加速度（1000.0）；
步进电机6.setMaxSpeed（1800.0）；
步进6.设定加速度（1000.0）；
步进电机7.setMaxSpeed（1800.0）；
步进7.设定加速度（1000.0）；
步进电机8.setMaxSpeed（1800.0）；
步进8.设定加速度（1000.0）；
步进电机9.setMaxSpeed（1800.0）；
步进9.设定加速度（1000.0）；
步进10.设定最大速度（1800.0）；
步进10。设定加速度（1000.0）；
步进11.设置最大速度（1800.0）；
步进11.设定加速度（1000.0）；
步进12.设置最大速度（1800.0）；
步进12.设定加速度（1000.0）；
步进13.设置最大速度（1800.0）；
步进13.设定加速度（1000.0）；
步进14.设置最大速度（1800.0）；
步进14.设定加速度（1000.0）；
}
void循环（）
{
如果（根据断开连接（））{
acc.read（rcvmsg，sizeof（rcvmsg），1）；
如果（rcvmsg[14]==命令指示灯）{
字节值=rcvmsg[15]；
如果（值==value\u ON）{
颜色[0]=rcvmsg[0]+128；
颜色[1]=rcvmsg[1]+128；
颜色[2]=rcvmsg[2]+128；
模拟写入（红色，贴图（颜色[0]，0，255，0，最大红色））；
analogWrite（绿色，贴图（颜色[1]，0，255，0，最大绿色））；
模拟写入（蓝针，地图（颜色[2]，0，255，0，最大蓝色））；
}
否则如果（值=值\u关闭）{
颜色[0]=0；
颜色[1]=0；
颜色[2]=0；
模拟写入（红色，贴图（颜色[0]，0，255，0，最大红色））；
analogWrite（绿色，贴图（颜色[1]，0，255，0，最大绿色））；
模拟写入（蓝针，地图（颜色[2]，0，255，0，最大蓝色））；
}
}
if（rcvmsg[14]==命令）{
字节值=rcvmsg[15]；
如果（值==value\u ON）{
//int sleepPin[16]={25,29,33,37,41,45,49,53,22,26,30,34,38,42,46,50}；
步进1.move（rcvmsg[0]*多路复用器）；
步进1.可设置引脚（25）；
步进2.移动（rcvmsg[1]*多画面机）；
步进2.可设置引脚（29）；
步进3.移动（rcvmsg[2]*多画面机）；
步进3.可设置引脚（33）；
步进4.移动（rcvmsg[3]*多画面机）；
步进4.可设置引脚（25）；
步进5.移动（rcvmsg[4]*多画面机）；
步进5.可设置引脚（37）；
步进6.移动（rcvmsg[5]*多画面机）；
步进6.可设置引脚（41）；
步进7.移动（rcvmsg[6]*多画面机）；
步进器7.可设置引脚（45）；
步进8.移动（rcvmsg[7]*多画面机）；
步进8.可设置引脚（49）；
步进9.移动（rcvmsg[8]*多画面机）；
步进9.可设置引脚（53）；
步进10.移动（rcvmsg[9]*多画面机）；
步进10。可设置引脚（22）；
步进11.移动（rcvmsg[10]*多画面机）；
步进11.可设置引脚（26）；
步进12.移动（rcvmsg[11]*多画面机）；
步进12.可设置引脚（30）；
步进13.移动（rcvmsg[12]*多画面机）；
步进13.可设置引脚（34）；
步进14.移动（rcvmsg[13]*多画面机）；
步进14.可设置引脚（38）；
}
else if（value==value\u OFF）{
stepper1.run（）；
if（stepper1.isRunning（）==false）{
步骤1.禁用输出（）；
}
stepper2.run（）；
if（StepR2.isRunning（）==false）{
步骤2.禁用输出（）；
}
stepper3.run（）；
if（StepR3.isRunning（）==false）{
步骤3.禁用输出（）；
}
stepper4.run（）；
if（stepper4.isRunning（）==false）{
步进4.禁用输出（）；
}
stepper5.run（）；
if（stepper5.isRunning（）==false）{
步骤5.禁用输出（）；
}
stepper6.run（）；
if（stepper6.isRunning（）==false）{
步进6.禁用输出（）；
}
stepper7.run（）；
if（stepper7.isRunning（）==false）{
步进7.禁用输出（）；
}
stepper8.run（）；
if（stepper8.isRunning（）==false）{
步进8.禁用输出（）；
}
stepper9.run（）；
if（stepper9.isRunning（）==false）{
步进9.禁用输出（）；
}
steper10.run（）；
如果（步进10.isRu
AccelStepper *slot1;
AccelStepper *slot2;
Accelstepper *slot3;

slot1 = &stepper1;