Patch following music to control motor. work in progress ;)

The motors I have are Nema 23 which are 1.8° for 200 steps.

The holding torque is 1.2 N.m

I divide the step size by 16 thanks to my good digital drivers.

So I have 3200 steps and a precision of 1.8/16 = 0.113 degrees per step

This way the motors are driven silently and without tremors

I think counting revolutions is no longer useful if you add or subtract the engine positions from the previous positions.

On the other hand, I want to be able to control the directions of global rotation, so we keep the current configuration of the patch with CW and CWW

For the Arduino part,

There is no need to control the direction of rotation with my digital drivers

I use the acceleStepper library

You can modulate the speed and acceleration

I rotate a 30 gram aluminum bar on which I attached an 8*32 LED strip

I also have a small box with a fairly heavy battery (the same as for electric cigarettes) which I fixed on the aluminum bar as close as possible to the axis of rotation of the motor.

In total I'm running something weighing 120 grams.

So, absolutely no sudden movement is necessary.

I can get the motors to run at two revolutions/sec

A maximum acceleration of 1 revolution/sec seems more than sufficient to me.

Here the Arduino code

#include <AccelStepper.h> // Define a stepper and the pins it will use
#define NBMOTEURS 10
#define NBDATA 34
#define NBPASPARTOUR 3200 // numberOfStep/round  

long ABC[NBDATA] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; // Teensy has to parse 34 ints fromMaxForLive
//position == data from 0 to 9 
//speed == data from 10 to 19 
//acceleration == data from 20 to 29 
//other data from Max4Live == data from 30 to 33
 
#define STEP 1//. set driver to subdivise step.
// 800-->Mode 1/4 pas MS2 sur ON
// 1600-->Mode 1/8 MS1+ MS2 sur ON
// 3200--> Mode 1/16 MS3 sur ON
// 6400--> Mode 1/32 MS1+ MS3 sur ON

//  Teensy (better than Arduino) 
 const uint8_t PINDIRECTION[NBMOTEURS] = {6, 9, 12, 26, 29, 32, 34, 37, 39, 41 };    
 const uint8_t PINSPEED[NBMOTEURS]=      {5, 8, 11, 25, 28, 31, 33, 36, 38, 40 };    
 const uint8_t ENABLEPIN[NBMOTEURS]=     {4, 7, 10, 24, 27, 30, 133, 135, 139, 142}; 

// Define a stepper and the pins it will use 
AccelStepper stepper[ NBMOTEURS] = {
AccelStepper (STEP, PINSPEED[0], PINDIRECTION[0]), 
AccelStepper (STEP, PINSPEED[1], PINDIRECTION[1]), 
AccelStepper (STEP, PINSPEED[2], PINDIRECTION[2]), 
AccelStepper (STEP, PINSPEED[3], PINDIRECTION[3]), 
AccelStepper (STEP, PINSPEED[4], PINDIRECTION[4]),  
AccelStepper (STEP, PINSPEED[5], PINDIRECTION[5]), 
AccelStepper (STEP, PINSPEED[6], PINDIRECTION[6]),  
AccelStepper (STEP, PINSPEED[7], PINDIRECTION[7]), 
AccelStepper (STEP, PINSPEED[8], PINDIRECTION[8]),  
AccelStepper (STEP, PINSPEED[9], PINDIRECTION[9]),
};
   
//   Receive with start- and end-markers combined with parsing
const byte numChars = 200;
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

    // variables to hold the parsed data
char messageFromPC[numChars] = {0}; //or 5 doesn't change anything

int enableDriver1= 0; // test enable driver. I don't need but I wanted to test
int led = 13;
boolean newData = false;

 // CHECK NUMBER OF ROUND AND GOOD MOVEMENT

int testOneRevolution;

void setup() {

    Serial.begin (115200); 
    
 for(uint8_t i = 0; i < NBMOTEURS; i++) { 
  stepper[i].setMinPulseWidth(5); //****************************************if TEENSY's clock is very fast, motor needs a little pulse

    // Initialisation des pins moteurs 
    pinMode(ENABLEPIN[i], OUTPUT);
    digitalWrite(ENABLEPIN[i], OUTPUT);
    digitalWrite(ENABLEPIN[i], LOW);
    
    pinMode(PINDIRECTION[i], OUTPUT);
    digitalWrite(PINDIRECTION[i], OUTPUT);
    pinMode(PINSPEED[i], OUTPUT);
    digitalWrite(PINSPEED[i], OUTPUT);

   stepper[i].setMaxSpeed(NBPASPARTOUR*2); // 6400 step*sec^-1
     }
     
  testOneRevolution=NBPASPARTOUR;

  ABC[NBDATA-2] =1; // ratioSpeed. // maybe I will use
  ABC[NBDATA-1] =2; // ratioAcc // // maybe I will use
  enableDriver1 =1; // enable driver 1 // just to test

 for (int i =0; i<NBMOTEURS; i++) // setPositionToMotor
   {    
       ABC[i]=testOneRevolution;  // 
       stepper[i].moveTo(ABC[i]); 
       stepper[i].run();
    }
   
 for (int i =NBMOTEURS; i<NBMOTEURS+10; i++) //setSpeedToMotor
   {      
       ABC[i]=600;  
       Serial.print( "  speed " + (i)); Serial.println(ABC[i] );
    }
 for (int i =NBMOTEURS+10; i<NBMOTEURS+20; i++) //setAccToMotor
   {      
       ABC[i]=300;  
       Serial.print( "  acc " + (i)); Serial.println(ABC[i] );
    }
 
Serial.print( " SPEED "); Serial.println(600_steps_made_in_one_sec);     
   }
   
void loop() { 

 for(uint8_t i = 0; i < NBMOTEURS; i++) { 
    stepper[i].setMaxSpeed(ABC[i+10]);  // speed is set from Max
    stepper[i].setAcceleration(ABC[i+20]);  //acceleration is set from Max

    //SPEED MAX
     if (  3200+ (1 * ABC[i+10] *1.0*ABC[NBDATA-2])>= NBPASPARTOUR*2)
      {
      stepper[i].setMaxSpeed(NBPASPARTOUR*2);
      } 

   } 
   recvWithStartEndMarkers(); // receive data like that <10,258,.....,-32> //  then split them
    if (newData == true) {
        strcpy(tempChars, receivedChars);
            // this temporary copy is necessary to protect the original data
            //   because strtok() used in parseData() replaces the commas with \0
        parseData();  
        newData = false;
    }

     moveMotorSetOneByOne();  // i control motor differently because they are not linked to the driver in the same "way of rotation"   
  }

void recvWithStartEndMarkers() {
    static boolean recvInProgress = false;
    static byte ndx = 0;
    char startMarker = '<';
    char endMarker = '>';
    char rc;

    while (Serial.available() > 0 && newData == false) {
        rc = Serial.read();

        if (recvInProgress == true) {
            if (rc != endMarker) {
                receivedChars[ndx] = rc;
                ndx++;
                if (ndx >= numChars) {
                    ndx = numChars - 1;
                }
            }
            else {
                receivedChars[ndx] = '\0'; // terminate the string
                recvInProgress = false;
                ndx = 0;
                newData = true;
            }
        }

        else if (rc == startMarker) {
            recvInProgress = true;
        }
    }
}

//================================================================= RECEIVE 34 DATAS FROM MAX_FOR_LIVE

void parseData() {      // split the data into its parts

    char * strtokIndx; // this is used by strtok() as an index
    strtokIndx = strtok(tempChars,",");      // get the first part - the string

    for(uint8_t i = 0; i < NBDATA; i++) { 
    ABC[i] = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    }
    }

void moveMotorSetOneByOne(). // sometimes there is -ABC[9] or  ABC[7]... because my motors are not plugged in the same rotation way. 
 {
       stepper[9].moveTo(-ABC[9]); 
       stepper[9].run();
       
       stepper[8].moveTo(-ABC[8]); 
       stepper[8].run();
        
       stepper[7].moveTo(ABC[7]); 
       stepper[7].run();
       
       stepper[6].moveTo(ABC[6]); 
       stepper[6].run();
     
       stepper[5].moveTo(ABC[5]); 
       stepper[5].run();
       
       stepper[4].moveTo(-ABC[4]);
       stepper[4].run();

       stepper[3].moveTo(-ABC[3]);
       stepper[3].run(); 

       stepper[2].moveTo(-ABC[2]);
       stepper[2].run();

       stepper[1].moveTo(-ABC[1]);
       stepper[1].run();

       stepper[0].moveTo(ABC[0]); //
       stepper[0].run();
}