Go Down

Topic: Stepper motors don't go as fast as they should. (Read 670 times) previous topic - next topic

bvking


Hi there,

My Arduino program is made to follow positions send by the serial at 115200 baud.
I receive 10 different positions from the software Processing.
My motors make 200 step for a round and I set 1/8 step in the driver, so I make 200*8 step for a round.

I set in the Arduino program, the speed and acceleration like that:

 stepper.setMaxSpeed(3200); // with 1600 step/round
 stepper.setAcceleration(2000);   

In theory,   my motors have to turn at 2 rounds/s with an acceleration of 2000 step in one seconde.

Actually when motors follow the simulation from Processing they can't go as faster than 1 rounds/s.

But when I stop the Processing program, the motors accelerate as if they are catching up and they do two revolutions per second well. :o

Maybe, when in the simulation, the positions of the motors involve to go to a big speed,   the Arduino program have too much   datas to compute when datas reach in the serial port?

It's a sort of an overflow? :smiley-confuse:

And when I stop the simulation, there are no data any more to compute and it is easier for the Arduino to compute   datas ?

I put my program in attachment because It 's a bit too long.

Thanks for your help and attention.
 

Robin2

#1
Sep 02, 2020, 12:28 pm Last Edit: Sep 02, 2020, 12:28 pm by Robin2
It would be a big help if you could post a short program that illustrates the problem. I'm afraid I don't have the patience to wade through 19k of code.

What do you mean by "in the simulation"? Do you mean that you have not tested the program with real hardware?

I have not looked at your code but my wild guess is that your code is preventing loop() from repeating fast enough for stepper.run() to produce the required step rate. Ideally it needs to be called 2 or 3 time more often than the desired step rate, and more often would be better.

...R
Two or three hours spent thinking and reading documentation solves most programming problems.

JCA34F

Which Arduino?
From the accelStepper library:
Quote
The fastest motor speed that can be reliably supported is about 4000 steps per
        second at a clock frequency of 16 MHz on Arduino such as Uno etc.

bvking

#3
Sep 02, 2020, 05:33 pm Last Edit: Sep 02, 2020, 05:45 pm by bvking
 
Hi dear Robin,

I made a version light of my program driving only two motor and receiving the 10 positions of my animation, not a simulation, from Processing.
Where can I repeat three time the positions to send to the stepper motors?

This data I read in the monitor of the Arduino.
A is the position from Processing. A Jo is the position computed in the loop and send into the stepper motor.
Code: [Select]

17:14:46.129 -> A 424  A Jo 11624 B 264  B Jo 11464 C 104  C JO 11304 D 1544  D Jo 11144 E 1384  E Jo   10984 F 1224  F Jo   10824 G 1064  E Jo   12264 H 904  E Jo   12104 I 744  E Jo   11944 J 584  J Jo   11784
 
17:14:46.165 -> A 436  A Jo 11636 B 276  B Jo 11476 C 116  C JO 11316 D 1556  D Jo 11156 E 1396  E Jo   10996 F 1236  F Jo   10836 G 1076  E Jo   12276 H 916  E Jo   12116 I 756  E Jo   11956 J 596  J Jo   11796


My light version program

Code: [Select]

 //*************Position from Processing

int processingPosition, processingPosition1,processingPosition2, processingPosition3, processingPosition4;
int processingPosition5, processingPosition6, processingPosition7, processingPosition8, processingPosition9;
 
#include <AccelStepper.h>

// Define a stepper and thAe pins it will use
#define NBMOTEURS 10

#define NBPASPARTOUR 1600 //Number of step for one round.

#define STEP 1///  200 steps--> 1/8  step one the driver  ==>  MS1+ MS2 sur ON selected on the driver
 
const uint8_t PINDIRECTION[NBMOTEURS] = { 11, 7, 3, 23, 27, 29, 31, 33, 35, 37};//{ 10, 6, 2, 22, 26};
const uint8_t PINSPEED[NBMOTEURS]= { 10, 6, 2, 22, 26, 28, 30, 32, 34, 36}; //{ 11, 7, 3, 23, 27};

// Define a stepper and the pins it will use
AccelStepper stepper[ NBMOTEURS] = {
AccelStepper (STEP, PINSPEED[0], PINDIRECTION[0]),
AccelStepper (STEP, PINSPEED[1], PINDIRECTION[1]),
 
};
 
int positionX, positionX1, positionX2, positionX3,positionX4,positionX5, positionX6, positionX7, positionX8, positionX9;

//*****************************THIS IS TO COMPUTEDELTA POSITION FROM PROCESSING IN ORDER MOTORS GO TO THE REAL POSITIONS
// For example if the  motor 0 has to go, in the animation, from the position 1600 to 1. The function computeDeltaPosition transform the position 1 into 1601.
// At the second revolution it transform 1 from the animation, into 3201 and so on.

//I let only the compucomputeDeltaPosition for the motor 0 and 1
 
int16_t computeDeltaPosition( uint16_t processingPosition) {
   static uint16_t oldPositionAbsolue = 0;
   uint16_t positionAbsolue = processingPosition;
   int16_t resultat;
   if(positionAbsolue < oldPositionAbsolue)
    positionAbsolue+=NBPASPARTOUR;
   if(positionAbsolue - oldPositionAbsolue < NBPASPARTOUR/2)
   resultat = positionAbsolue - oldPositionAbsolue;
  else
    resultat = positionAbsolue - oldPositionAbsolue - NBPASPARTOUR;
  oldPositionAbsolue = processingPosition;
  return resultat;

}
 
int16_t computeDeltaPosition1( uint16_t processingPosition1) {
   static uint16_t oldPositionAbsolue = 0;
   uint16_t positionAbsolue = processingPosition1;
   int16_t resultat;
   if(positionAbsolue < oldPositionAbsolue)
    positionAbsolue+=NBPASPARTOUR;
   if(positionAbsolue - oldPositionAbsolue < NBPASPARTOUR/2)
   resultat = positionAbsolue - oldPositionAbsolue;
  else
    resultat = positionAbsolue - oldPositionAbsolue - NBPASPARTOUR;
  oldPositionAbsolue = processingPosition1;
  return resultat;

}
 
// Example 5 - Receive with start- and end-markers combined with parsing

const byte numChars = 200;//64
char receivedChars[numChars];
char tempChars[numChars];        // temporary array for use when parsing

      // variables to hold the parsed data
char messageFromPC[numChars] = {0}; //not used for the moment

 
// POSITION FROM PROCESSING
int PC0= 0;
int PC1= 0;
int PC2= 0;
int PC3= 0;
int PC4= 0;
int PC5= 0;
int PC6= 0;
int PC7= 0;
int PC8= 0;
int PC9= 0;

 
float floatFromPC = 0.0; // not used for the moment

boolean newData = false; // In order to not copy any datas from the serial if there is no datas coming.

//============


void setup() {
    Serial.begin (115200);
    SerialUSB.begin (115200); // it doesn't make any sens but i prefer
     
 for(uint8_t i = 0; i < NBMOTEURS; i++) {
   
    // Initialisation des pins moteurs
    pinMode(PINDIRECTION[i], OUTPUT);
    digitalWrite(PINDIRECTION[i], OUTPUT);
    pinMode(PINSPEED[i], OUTPUT);
    digitalWrite(PINSPEED[i], OUTPUT);
 
// with  1/8 step --> 200*8= 1600 step / round

  stepper[i].setMaxSpeed(3200); // sur 1600 step/round
  stepper[i].setAcceleration(2000);  // MAX 3000?
   }

}

void loop() {
   
  recvWithStartEndMarkers();
    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();

   
  processingPosition = PC0;
  processingPosition1 = PC1;
 
  positionX += computeDeltaPosition(processingPosition);
  positionX1+= computeDeltaPosition1(processingPosition1);
 
 
  controlVirtualJoPositionMotor();
 
 
        newData = false;
    }
   
       stepper[9].moveTo(positionX);
       stepper[9].run();
       stepper[8].moveTo(positionX1);
       stepper[8].run();       
       
 
    }

 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;
        }
    }
}

//============

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

    char * strtokIndx; // this is used by strtok() as an index

     

    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
   
    PC0 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC1 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC2 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC3 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC4 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC5 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC6 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC7 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC8 = atoi(strtokIndx);     // convert this part to an integer
    strtokIndx = strtok(NULL, ","); // this continues where the previous call left off
    PC9 = atoi(strtokIndx);     // convert this part to an integer
 
}

//============

void controlVirtualJoPositionMotor() {
 
    SerialUSB.print ("A "); SerialUSB.print (PC0);  SerialUSB.print ("  A Jo "); SerialUSB.print (positionX);   
    SerialUSB.print (" B "); SerialUSB.print (PC1);  SerialUSB.print ("  B Jo "); SerialUSB.print (positionX1);       
    SerialUSB.print (" C "); SerialUSB.print (PC2);  SerialUSB.print ("  C JO "); SerialUSB.print (positionX2);   
    SerialUSB.print (" D "); SerialUSB.print (PC3);  SerialUSB.print ("  D Jo "); SerialUSB.print (positionX3);       
    SerialUSB.print (" E "); SerialUSB.print (PC4);  SerialUSB.print ("  E Jo   "); SerialUSB.print (positionX4);
     
    SerialUSB.print (" F "); SerialUSB.print (PC5); SerialUSB.print ("  F Jo   "); SerialUSB.print (positionX5);   
    SerialUSB.print (" G "); SerialUSB.print (PC6); SerialUSB.print ("  E Jo   "); SerialUSB.print (positionX6);       
    SerialUSB.print (" H "); SerialUSB.print (PC7); SerialUSB.print ("  E Jo   "); SerialUSB.print (positionX7);   
    SerialUSB.print (" I "); SerialUSB.print (PC8); SerialUSB.print ("  E Jo   "); SerialUSB.print (positionX8);       
    SerialUSB.print (" J "); SerialUSB.print (PC9); SerialUSB.print ("  J Jo   "); SerialUSB.println (positionX9);
 

 



bvking


Robin2

Where can I repeat three time the positions to send to the stepper motors?
I don't understand that question.

Also please tell us in detail what the short program actually does and what you want it to do that is different. That way we can focus on the parts you need help with rather than wasting time on things that you can do.

How often is data sent from Processing?

Is this an example of a typical message sent from Processing
Code: [Select]
A 424  A Jo 11624 B 264  B Jo 11464 C 104  C JO 11304 D 1544  D Jo 11144 E 1384  E Jo   10984 F 1224  F Jo   10824 G 1064  E Jo   12264 H 904  E Jo   12104 I 744  E Jo   11944 J 584  J Jo   11784

...R
Two or three hours spent thinking and reading documentation solves most programming problems.

bvking

#6
Sep 03, 2020, 01:15 pm Last Edit: Sep 03, 2020, 01:28 pm by bvking
Hi Robin,

I changed my Processing program and I send twice the same data at each frame.  
Actually I send 31 datas twice, but only 10 datas are useful to control positions

I changed my Arduino program. I can read at the same time, twice the 10 positions.  Now I receive exactly the 10 positions (twice ) from Processing without any change in Arduino. Positions go directly in the void loop like that:

stepper[9].moveTo(PC0);
stepper[9].run();
stepper[9].moveTo(PC0);
stepper[9].run();
stepper[8].moveTo(PC1);
stepper[8].run();
stepper[8].moveTo(PC1);
stepper[8].run();

I repeat this command a second time as you suggested because you told me in the post #1 "my wild guess is that your code is preventing loop() from repeating fast enough for stepper.run() to produce the required step rate"

So please could you have a look in the void loop of my program and tell me if I repeat the good command to send datas to the stepper?

Code: [Select]

 
//   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 integerFromPC0 = 0;
int integerFromPC1 = 0;
int integerFromPC2 = 0;
int integerFromPC3 = 0;
int integerFromPC4 = 0;
int integerFromPC5 = 0;
int integerFromPC6 = 0;
int integerFromPC7 = 0;
int integerFromPC8 = 0;
int integerFromPC9 = 0;

int PC0= 0;
int PC1= 0;
int PC2= 0;
int PC3= 0;
int PC4= 0;
int PC5= 0;
int PC6= 0;
int PC7= 0;
int PC8= 0;
int PC9= 0;

int PCTer0= 0;
int PCTer1= 0;
int PCTer2= 0;
int PCTer3= 0;
int PCTer4= 0;
int PCTer5= 0;
int PCTer6= 0;
int PCTer7= 0;
int PCTer8= 0;
int PCTer9= 0;

int orderCohesion  = 0;

float floatFromPC = 0.0; // not used for the moment

boolean newData = false;

//============
 
void setup()
{  
    Serial.begin (115200);
    SerialUSB.begin (115200); // it doesn't make any sens but i prefer
 
 //====Initialise Pin Motor
    
 for(uint8_t i = 0; i < NBMOTEURS; i++) {
  
    pinMode(PINDIRECTION[i], OUTPUT);
    digitalWrite(PINDIRECTION[i], OUTPUT);
    pinMode(PINSPEED[i], OUTPUT);
    digitalWrite(PINSPEED[i], OUTPUT);

/// with 1/8 step==> 200*8=1600 step for a round
  stepper[i].setMaxSpeed(3200); // 2 round in one sec but I can go to 1 round in one sec
  stepper[i].setAcceleration(3000);  // MAX  ?
 // stepper[i].setSpeed(3200);
   }
}

void loop() {

   recvWithStartEndMarkers();
    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(); // 31 datas marked and separated with a coma.  
        showPosition();
   //     showPhazisScaled();
   //     showTrigBangWithRevolution();
        newData = false;
    }
  
       stepper[9].moveTo(PC0);
       stepper[9].run();
       stepper[8].moveTo(PC1);
       stepper[8].run();      
       stepper[7].moveTo(PC2);
       stepper[7].run();
       stepper[6].moveTo(PC3);
       stepper[6].run();
       stepper[5].moveTo(PC4);  
       stepper[5].run();
       stepper[4].moveTo(PC5);
       stepper[4].run();
       stepper[3].moveTo(PC6);
       stepper[3].run();      
       stepper[2].moveTo(PC7);
       stepper[2].run();
       stepper[1].moveTo(PC8);
       stepper[1].run();
       stepper[0].moveTo(PC9);  
       stepper[0].run();

// I repeat the command as you advice me?
       stepper[9].moveTo(PC0);
       stepper[9].run();
       stepper[8].moveTo(PC1);
       stepper[8].run();      
       stepper[7].moveTo(PC2);
       stepper[7].run();
       stepper[6].moveTo(PC3);
       stepper[6].run();
       stepper[5].moveTo(PC4);  
       stepper[5].run();
       stepper[4].moveTo(PC5);
       stepper[4].run();
       stepper[3].moveTo(PC6);
       stepper[3].run();      
       stepper[2].moveTo(PC7);
       stepper[2].run();
       stepper[1].moveTo(PC8);
       stepper[1].run();
       stepper[0].moveTo(PC9);  
       stepper[0].run();
  
}

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;
        }
    }
}
 
 
 

Robin2

#7
Sep 03, 2020, 04:04 pm Last Edit: Sep 03, 2020, 04:04 pm by Robin2
I'm sorry, but I'm a simple soul with a very old brain.

It will be much easier to help if you answer the questions I asked in Reply #5. I need that to understand the context of your questions and your problem.

If you have changed the the message that Processing is sending then please provide an example of the new messages.

...R
Two or three hours spent thinking and reading documentation solves most programming problems.

MarkT

You need to call run() frequently for each motor and _not_ call moveTo() unless the destination has
changed.  With that many motors AccelStepper may struggle a bit.

Anything that takes processor time and thus delays calling the run() methods will slow down the
motors - this is how AccelStepper works.

BTW you should learn about arrays, you can lose all this repetitive code that way.
[ I will NOT respond to personal messages, I WILL delete them, use the forum please ]

bvking

If you have changed the the message that Processing is sending then please provide an example of the new messages.
 
An example of the frame 769 and 770 of what I send  from Processing

769: <11662,11662,11662,11662,11662,11662,11662,11662,11662,11662,16959,16959,16959,16959,16959,16959,16959,16959,16959,16959,1234,1234,1234,1234,1234,1234,1234,1234,1234,1234,1234>

770: <11896,11896,11896,11896,11896,11896,11896,11896,11896,11896,16986,16986,16986,16986,16986,16986,16986,16986,16986,16986,1234,1234,1234,1234,1234,1234,1234,1234,1234,1234,1234>


Only data from 10 to 20 are used to control stepper motor.
In the Arduino program, I add letter  L, M ... T to each position. We can see in the serial monitor of the Arduino this datas


16:50:31.240 -> L 16959
16:50:31.240 -> M 16959
16:50:31.240 -> N 16959
16:50:31.240 -> O 16959
16:50:31.240 -> P 16959
16:50:31.240 -> Q 16959
16:50:31.240 -> R 16959
16:50:31.240 -> S 16959
16:50:31.240 -> T 16959
16:50:31.278 -> K 16986
16:50:31.278 -> L 16986
16:50:31.278 -> M 16986
16:50:31.278 -> N 16986
16:50:31.278 -> O 16986
16:50:31.278 -> P 16986
16:50:31.278 -> Q 16986
16:50:31.278 -> R 16986
16:50:31.278 -> S 16986
16:50:31.278 -> T 16986

In this example, my ten motors go to the same positions.


bvking

#10
Sep 03, 2020, 05:03 pm Last Edit: Sep 03, 2020, 05:23 pm by bvking
You need to call run() frequently for each motor and _not_ call moveTo() unless the destination has
changed.  
As you can see in my example above, the destination change at each frame in Processing, that we can see in the Arduino monitor.  
I have 30 frame in one seconde in Processing.

Do you mean I have to add stepper.run like this?


stepper[9].moveTo(PC0);
stepper[9].run();
stepper[9].run();
stepper[9].run();
stepper[8].moveTo(PC1);
stepper[8].run();
stepper[8].run();
stepper[8].run();

It doesn't change anything :(


Robin2

An example of the frame 769 and 770 of what I send  from Processing
That answers one of my questions. But you still have not responded to the more important questions in Reply #5 which are
Quote
Also please tell us in detail what the short program actually does and what you want it to do that is different. That way we can focus on the parts you need help with rather than wasting time on things that you can do.

How often is data sent from Processing?
...R
Two or three hours spent thinking and reading documentation solves most programming problems.

bvking

#12
Sep 03, 2020, 06:04 pm Last Edit: Sep 03, 2020, 06:26 pm by bvking
My Arduino program receives 31 processing data 30 times per second.
Of these 31 data, I use 10 that I assign to the 10 stepper motors.

Little by little in Processing, I increment the positions of the 10 motors with more and more gap. For example at frame 1, I go from 1 to 10, and at frame 2 from 10 to 25. At the beginning I go 10 steps forward, then 15 steps.

The motors follow the data well, which has the effect of increasing their speed.

But at the end of too great a gap, the motors no longer increase their speed and they turn at 1 revolution per sec, or 1600 steps per second.

But when I stop the Processing animation, the motors speed up. As if the fact of not receiving any more information, allowed the Arduino board to do its job better.

I would like that my motors go faster. Is it possible?

Finally, the 10 position data is sent by Processing once per frame. As I have 30 frames per second, I send 30 * 10 different positions per second.

But since, I need to send more than the 10 positions to the Arduino board, I'm actually sending, 30 * 31 data per second to the Arduino Due board.

Hoping for your enlightenment, I am in advance gratifying for your next response.

Robin2

#13
Sep 03, 2020, 08:15 pm Last Edit: Sep 03, 2020, 08:17 pm by Robin2
My Arduino program receives 31 processing data 30 times per second.
That's going to use up a lot of Arduino time. Does it really have to send that often? Why not (say) 5 times per second?

Maybe you could modify things so that Processing sends info that allows the Arduino to act autonomously for some time, rather than getting every separate data item from Processing.

Also, what is the purpose of all the data that has nothing to do with the motors?  Why are you bothering to send that?

...R
Two or three hours spent thinking and reading documentation solves most programming problems.

bvking

Hello,


I send the 31 processing data 1 frame out of 6 to the serial port of the Arduino.
I have 30 frame in one sec, so I send position 5 time in one seconde.

But now my movement is very jerky.


I send my 31 datas in this way from Processing

Code: [Select]

  
   if(frameCount%6 == 0){   //I have 30 frame in one sec, so I send position 5 time in one seconde
    
     for (int i = 0; i < 1; i++) { // make this command once
     arduinoport.write( dataMarked); // Send data to Arduino.
      println(frameCount + ": " + ( dataMarked));
   }




The other data I send is used to modulate synthesizer filters and trigger sound effects when the motors are in their 0 position.

I really need this data to be fluid.

 
I read this in the serial monitor of the Arduino.
Code: [Select]

 
13:25:44.356 -> K 32341
13:25:44.356 -> L 29213
13:25:44.356 -> M 34086
13:25:44.356 -> N 35758
13:25:44.356 -> O 31031
13:25:44.356 -> P 27903
13:25:44.356 -> Q 35975
13:25:44.356 -> R 34448
13:25:44.356 -> S 29720
13:25:44.356 -> T 32993
13:25:44.565 -> K 32384
13:25:44.565 -> L 29256
13:25:44.565 -> M 34129
13:25:44.565 -> N 35801
13:25:44.565 -> O 31073
13:25:44.565 -> P 27946
13:25:44.565 -> Q 36018
13:25:44.565 -> R 34491
13:25:44.565 -> S 29763
13:25:44.565 -> T 33035
13:25:44.779 -> K 32427
13:25:44.779 -> L 29299
13:25:44.779 -> M 34171
13:25:44.779 -> N 35844
13:25:44.779 -> O 31116
13:25:44.779 -> P 27989
13:25:44.779 -> Q 36061
13:25:44.779 -> R 34533
13:25:44.779 -> S 29806
13:25:44.779 -> T 33078
13:25:44.991 -> K 32469
13:25:44.991 -> L 29342
13:25:44.991 -> M 34214
13:25:44.991 -> N 35887
13:25:44.991 -> O 31159
13:25:44.991 -> P 28031
13:25:44.991 -> Q 36104
13:25:44.991 -> R 34576
13:25:44.991 -> S 29849
13:25:44.991 -> T 33121
13:25:45.208 -> K 32512
13:25:45.208 -> L 29385
13:25:45.208 -> M 34257
13:25:45.208 -> N 35929
13:25:45.208 -> O 31202
13:25:45.208 -> P 28074
13:25:45.208 -> Q 36147
13:25:45.208 -> R 34619
13:25:45.208 -> S 29891
13:25:45.208 -> T 33164
13:25:45.415 -> K 32555
13:25:45.415 -> L 29427
13:25:45.415 -> M 34300
13:25:45.415 -> N 35972
13:25:45.415 -> O 31245
13:25:45.415 -> P 28117
13:25:45.415 -> Q 36189
13:25:45.415 -> R 34662
13:25:45.415 -> S 29934
13:25:45.415 -> T 31607

Go Up