Phil2P

Merci beaucoup Ludovic Dille et Sandro pour vos conseils précieux.

Je vais tester vos solutions dès que je retrouve un peu de temps et je viendrais vous montrer le résultat.

 

Je vous souhaite une très bonne soirée,

Philippe

Bonsoir,

"Donc tant que tu n'as pas entièrement reçu la trame, plus rien ne se passe."

Nous souhaitons que l'Arduino commence à mettre en mouvement toutes les articulations en même temps.

Il faut pour cela qu'il ait reçu toutes les infos nécessaires inclues dans une trame..

 

Nous allons augmenter la vitesse de transmission sur l'Arduino et le PC à 115200 bits/s. Merci !

 

La solution N°1, la plus simple, me semble en effet que l'Arduino envoie un signal au PC lorsque les moteurs sont arrivées dans la configuration choisie. Il reste à tenir compte tout de même d'un éventuel "STOP" envoyé du PC OU d'un appui sur l’arrêt d'urgence qui, pour l'instant, coupe brutalement l'alimentation.

 

Pour la FIFO, 125 "trames d'avance" seraient largement suffisant. En effet, la solution N°2 serait alors d'envoyer toutes les trames et de laisser l'Arduino finir tranquillement son travail.

 

La solution N°3 serait d'utiliser "dynamiquement" la FIFO et d'envoyer au fur et à mesure les trames du PC à l'Arduino. Chacun travaillant à son rythme...

 

Voyez-vous une meilleur solution ?

 

Est-ce qu'une librairie comme CircularBuffer, MD_CirQueue ou Ringbuf permettrait de mettre en œuvre une FIFO pour les solutions 2 et 3 ?

 

Merci de partager vos connaissances et votre expérience.

 

Je vous souhaite une très bonne soirée,

Philippe

 

 

 

 

 FirmwareArduinoV1.ino   13,53 Ko   143 téléchargement(s)

/*
 * Commande Robot depuis Scilab
 * 
 * Créé par P. Dalmeida et P. de Poumayrac
 * Version du 17/03/2021
 */

/* format des commandes utilisées
     'M q1 q2 q3 q4 q5 q6' : Mouvement en coordonées articulaires absolues
     'P pince' : Mouvement de la pince.
     'T q1 s1 q2 s2 q3 s3 q4 s4 q5 s5 q6 s6' : 
     'S' : Stops the motor immediately.
     'F' : Updates the position current position and makes it as the new values.
 */
 
#include <AccelStepper.h> // Importation librairie gestion des Steppers
#include <Wire.h>         // Importation librairie gestion port I2C
#include <Servo.h>        // Importation librairie gestion servomoteur

Servo pince;              // create servo object to control a servo

const int colorR = 255;   // Couleur fond écran
const int colorG = 0;
const int colorB = 0;
const int step1=200;     // Nb Step Motor 1
const int step2=200;     // Nb Step Motor 2
const int step3=200;     // Nb Step Motor 3
const int step4=200;     // Nb Step Motor 4
const int step5=200;     // Nb Step Motor 5
const int step6=200;     // Nb Step Motor 6

float q1 = 0;                       // Angles
float q2 = 0;
float q3 = 0;
float q4 = 0;
float q5 = 0;
float q6 = 0;
float r1 = 8.333;                       // Rapports de réduction
float r2 = 5.5;
float r3 = 21.429;
float r4 = 1;
float r5 = 3.667;
float r6 = 1;

long receivedSteps1;                // Number of steps
long receivedSpeed1 = 100;          // Steps / second
long receivedAcceleration1 = 50;   // Steps / second^2
long receivedSteps2;                // Number of steps
long receivedSpeed2 = 100;          // Steps / second
long receivedAcceleration2 = 50;   // Steps / second^2
long receivedSteps3;                // Number of steps
long receivedSpeed3 = 100;          // Steps / second
long receivedAcceleration3 = 50;   // Steps / second^2
long receivedSteps4;                // Number of steps
long receivedSpeed4 = 100;          // Steps / second
long receivedAcceleration4 = 50;   // Steps / second^2
long receivedSteps5;                // Number of steps
long receivedSpeed5 = 100;          // Steps / second
long receivedAcceleration5 = 50;   // Steps / second^2
long receivedSteps6;                // Number of steps
long receivedSpeed6 = 100;          // Steps / second
long receivedAcceleration6 = 50;   // Steps / second^2
long receivedGripper;
char receivedCommand;

bool newData, runallowed = false;   // booleans for new data from serial, and runallowed flag

#define STEPPER1_DIR_PIN 2
#define STEPPER1_STEP_PIN 3
#define STEPPER2_DIR_PIN 4
#define STEPPER2_STEP_PIN 5
#define STEPPER3_DIR_PIN 6
#define STEPPER3_STEP_PIN 7
#define STEPPER4_DIR_PIN 8
#define STEPPER4_STEP_PIN 9
#define STEPPER5_DIR_PIN 10
#define STEPPER5_STEP_PIN 11
#define STEPPER6_DIR_PIN 12
#define STEPPER6_STEP_PIN 13
#define motorInterfaceType 1

// Create a new instance of the AccelStepper class:
AccelStepper stepper1 = AccelStepper(motorInterfaceType, STEPPER1_STEP_PIN, STEPPER1_DIR_PIN);
AccelStepper stepper2 = AccelStepper(motorInterfaceType, STEPPER2_STEP_PIN, STEPPER2_DIR_PIN);
AccelStepper stepper3 = AccelStepper(motorInterfaceType, STEPPER3_STEP_PIN, STEPPER3_DIR_PIN);
AccelStepper stepper4 = AccelStepper(motorInterfaceType, STEPPER4_STEP_PIN, STEPPER4_DIR_PIN);
AccelStepper stepper5 = AccelStepper(motorInterfaceType, STEPPER5_STEP_PIN, STEPPER5_DIR_PIN);
AccelStepper stepper6 = AccelStepper(motorInterfaceType, STEPPER6_STEP_PIN, STEPPER6_DIR_PIN);

void setup()
{
    Serial.begin(9600);
    Serial1.begin(9600);
    pince.attach(22);                                 // attaches the servo on pin 22 to the servo object
    //setting up some default values for maximum speed and maximum acceleration
    stepper1.setMaxSpeed(receivedSpeed1);             //SPEED = Steps / second
    stepper1.setAcceleration(receivedAcceleration1);  //ACCELERATION = Steps /(second)^2
    stepper2.setMaxSpeed(receivedSpeed2);             //SPEED = Steps / second
    stepper2.setAcceleration(receivedAcceleration2);  //ACCELERATION = Steps /(second)^2
    stepper3.setMaxSpeed(receivedSpeed3);             //SPEED = Steps / second
    stepper3.setAcceleration(receivedAcceleration3);  //ACCELERATION = Steps /(second)^2
    stepper4.setMaxSpeed(receivedSpeed4);             //SPEED = Steps / second
    stepper4.setAcceleration(receivedAcceleration4);  //ACCELERATION = Steps /(second)^2
    stepper5.setMaxSpeed(receivedSpeed5);             //SPEED = Steps / second
    stepper5.setAcceleration(receivedAcceleration5);  //ACCELERATION = Steps /(second)^2
    stepper6.setMaxSpeed(receivedSpeed6);             //SPEED = Steps / second
    stepper6.setAcceleration(receivedAcceleration6);  //ACCELERATION = Steps /(second)^2 
    stepper1.disableOutputs();                        //disable outputs
    stepper2.disableOutputs();                        //disable outputs
    stepper3.disableOutputs();                        //disable outputs
    stepper4.disableOutputs();                        //disable outputs
    stepper5.disableOutputs();                        //disable outputs
    stepper6.disableOutputs();                        //disable outputs
}

void loop()
{
    checkSerial(); //check serial port for new commands
    RunTheMotor(); //function to handle the motor
}

void checkSerial() //function for receiving the commands
{  
if (Serial.available() > 0) //if something comes from the computer
    {
        receivedCommand = Serial.read(); // pass the value to the receivedCommad variable
        newData = true; //indicate that there is a new data by setting this bool to true
 
        if (newData == true) //we only enter this long switch-case statement if there is a new command from the computer
        {
            switch (receivedCommand)      //we check what is the command
            {
 
            case 'M':     //M is used to move the robot absolutely to the current position           
               
                receivedSteps1 = Serial.parseFloat();
                receivedSteps2 = Serial.parseFloat(); 
                receivedSteps3 = Serial.parseFloat();
                receivedSteps4 = Serial.parseFloat();
                receivedSteps5 = Serial.parseFloat();
                receivedSteps6 = Serial.parseFloat();

                receivedSpeed1 = 50*r1;
                receivedSpeed2 = 50*r2;
                receivedSpeed3 = 50*r3;
                receivedSpeed4 = 50*r4;
                receivedSpeed5 = 50*r5;
                receivedSpeed6 = 50*r6;
                
                RotateAbsolute();         //Run the function
                
                break;         

            case 'P':     //P is used to move the robot gripper           
               
                receivedGripper = Serial.parseFloat();
                
                receivedGripper = map(receivedGripper, 0, 100, 95, 40); // scale it to use it with the servo (value between 0 and 180)
                pince.write(receivedGripper);                           // sets the servo position according to the scaled value
                delay(15);                                              // waits for the servo to get there

                break;         

            case 'T':       //T is used to move the robot absolutely to the current position           
               
                receivedSteps1 = Serial.parseFloat();
                receivedSpeed1 = Serial.parseFloat();
                receivedAcceleration1 = Serial.parseFloat();
                receivedSteps2 = Serial.parseFloat();
                receivedSpeed2 = Serial.parseFloat();
                receivedAcceleration2 = Serial.parseFloat(); 
                receivedSteps3 = Serial.parseFloat();
                receivedSpeed3 = Serial.parseFloat();
                receivedAcceleration3 = Serial.parseFloat();
                receivedSteps4 = Serial.parseFloat();
                receivedSpeed4 = Serial.parseFloat();
                receivedAcceleration4 = Serial.parseFloat();
                receivedSteps5 = Serial.parseFloat();
                receivedSpeed5 = Serial.parseFloat();
                receivedAcceleration5 = Serial.parseFloat();
                receivedSteps6 = Serial.parseFloat();
                receivedSpeed6 = Serial.parseFloat();
                receivedAcceleration6 = Serial.parseFloat();
                receivedGripper = Serial.parseFloat();
                receivedGripper = map(receivedGripper, 0, 100, 95, 40); // scale it to use it with the servo (value between 0 and 180)
                pince.write(receivedGripper);                           // sets the servo position according to the scaled value
                delay(15);                                              // waits for the servo to get there

                RotateAbsolute();         //Run the function
                
                break;         
  
            case 'S':                         // Stops the motor
               
                stepper1.stop();              //stop motor
                stepper1.disableOutputs();    //disable power
                stepper2.stop();              //stop motor
                stepper2.disableOutputs();    //disable power
                stepper3.stop();              //stop motor
                stepper3.disableOutputs();    //disable power
                stepper4.stop();              //stop motor
                stepper4.disableOutputs();    //disable power
                stepper5.stop();              //stop motor
                stepper5.disableOutputs();    //disable power
                stepper6.stop();              //stop motor
                stepper6.disableOutputs();    //disable power
                runallowed = false;           //disable running
                
                break;
 
            case 'F':
 
                runallowed = false;                 //we still keep running disabled
                receivedSteps1 = Serial.parseFloat();
                receivedSteps2 = Serial.parseFloat(); 
                receivedSteps3 = Serial.parseFloat();
                receivedSteps4 = Serial.parseFloat();
                receivedSteps5 = Serial.parseFloat();
                receivedSteps6 = Serial.parseFloat();

                stepper1.disableOutputs();          //disable power
                stepper2.disableOutputs();
                stepper3.disableOutputs();
                stepper4.disableOutputs();
                stepper5.disableOutputs();
                stepper6.disableOutputs();

                stepper1.setCurrentPosition(receivedSteps1);     //Reset current position. "new home"
                stepper2.setCurrentPosition(receivedSteps2);
                stepper3.setCurrentPosition(receivedSteps3);
                stepper4.setCurrentPosition(receivedSteps4);
                stepper5.setCurrentPosition(receivedSteps5);
                stepper6.setCurrentPosition(receivedSteps6);
             
                break; 
  
            default:  

                break;
            }
        }
        //after we went through the above tasks, newData is set to false again, so we are ready to receive new commands again.
        newData = false;       
    }
}

void RunTheMotor() //function for the motor
{
    if (runallowed == true)
    {
        stepper1.enableOutputs(); //enable pins
        stepper2.enableOutputs(); //enable pins
        stepper3.enableOutputs(); //enable pins
        stepper4.enableOutputs(); //enable pins
        stepper5.enableOutputs(); //enable pins
        stepper6.enableOutputs(); //enable pins
        stepper1.run();           //step the motor (this will step the motor by 1 step at each loop)
        stepper2.run();           //step the motor (this will step the motor by 1 step at each loop)
        stepper3.run();           //step the motor (this will step the motor by 1 step at each loop)
        stepper4.run();           //step the motor (this will step the motor by 1 step at each loop)
        stepper5.run();           //step the motor (this will step the motor by 1 step at each loop)
        stepper6.run();           //step the motor (this will step the motor by 1 step at each loop)
    }
    else //program enters this part if the runallowed is FALSE, we do not do anything
    {
        stepper1.disableOutputs(); //disable outputs
        stepper2.disableOutputs(); //disable outputs
        stepper3.disableOutputs(); //disable outputs
        stepper4.disableOutputs(); //disable outputs
        stepper5.disableOutputs(); //disable outputs
        stepper6.disableOutputs(); //disable outputs
        return;
    }
}

void RotateAbsolute()
{
    //We move to an absolute position.
    //The AccelStepper library keeps track of the position.
 
    runallowed = true; //allow running - this allows entering the RunTheMotor() function.
    stepper1.setMaxSpeed(receivedSpeed1);   //set speed
    stepper2.setMaxSpeed(receivedSpeed2);   //set speed
    stepper3.setMaxSpeed(receivedSpeed3);   //set speed
    stepper4.setMaxSpeed(receivedSpeed4);   //set speed
    stepper5.setMaxSpeed(receivedSpeed5);   //set speed
    stepper6.setMaxSpeed(receivedSpeed6);   //set speed
    stepper1.moveTo(receivedSteps1);        //set absolute position 
    stepper2.moveTo(receivedSteps2);        //set absolute position
    stepper3.moveTo(receivedSteps3);        //set absolute position 
    stepper4.moveTo(receivedSteps4);        //set absolute position
    stepper5.moveTo(receivedSteps5);        //set absolute position 
    stepper6.moveTo(receivedSteps6);        //set absolute position  
}

 

Bonjour Sandro,
Je te remercie pour ton aide.

Je veux bien partager mon code, mais je ne sais pas trop comment : j'ai essayé de le joindre à ce message. Tu me diras si ça a marché.

Il s'agit probablement d'un code récupéré sur le net par mes élèves car il y a des commentaires en anglais...

Pour pouvoir l'utiliser, nous trichons sur le PC en calculant grossièrement le temps de traitement d'une trame par l'Arduino et envoyant la trame suivante quand nous sommes sûrs que la trame actuelle est traitée. Cela occasionne probablement ces délais, retards et arrêts lors du traitement de plusieures trames successives.

Pour résoudre ce problème, nous avons donc pensé demander à l'Arduino d' envoyer une info au pc lorsque la trame actuelle est traitée pour que le pc puisse envoyer la nouvelle trame.

Pour envoyer plusieurs trames d'avance à l'Arduino, une autre solution serait une file Fifo (j'ai compris ta remarque je crois) qui ne devra supprimer une trame que lorsqu'elle a était traitée.
Ces trames sont composées de 12 float (un angle et une vitesse pour chaque articulation).
Quelle serait alors le nombre de trames que pourrait stocker notre Arduino Mega dans sa mémoire ?

Nous avons un niveau très faible en programmation Arduino. Je pensais qu'une librairie pourrait limiter les difficultés pour créer et utiliser cette file FIFO...

Encore merci de votre aide,
Philippe

Merci Ludovic !
Peux-tu me dire si une librairie comme "CircularBuffer" pourrait faciliter la création et l'utilisation d'une pile Fifo?

Je te souhaite une très bonne journée,
Philippe