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   116 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

Bonsoir,

La solution la plus simple semble donc :
Renvoyer linfo au PC lorsque la trame est traitée.

C'est vrai qu'une pile Fifo me plairait bien car elle permettrait d'envoyer plusieurs "trames d'avance" et laisserait l'Arduino traiter les trames "à son rythme".
En effet, nous ne sommes pas des pro. Loin de là... 😉
Je croyais qu'un librairie comme "CircularBuffer" aurait pu faciliter l'utilisation d'une pile Fifo.

Tu trouveras ci-dessous un lien pour voir le 1er proto du bras en fonctionnement.




Encore merci de ton aide précieuse,
Philippe

Bonsoir,
Merci Ludovic pour tes conseils.

Les trames comportent une lettre (M pour Mouvement, P pour Pince et S pour Stop) et contiennent les positions articulaires finales attendues lors d'un mouvement. Pour une trajectoire complexe, on peut décomposer cette trajectoire par plusieurs points dans l'espace correspondants chacun à des positions articulaires finales attendues.

Je pense que les soucis actuels résultent du fait que l'envoi d'une nouvelle trame interompe (par l'utilisation de CASE) l'exécution de la précédente. Nous avons triché en imposant sur le PC un délai grossièrement calculé entre chaque envoi de trame.

D'où mon idée d'envoyer au PC une info indiquant que l'exécution de la trame est terminée pour pouvoir envoyer une nouvelle trame.
Ou, autre solution, utiliser une sorte de pile Fifo sur la carte Arduino.

Qu'en pensez-vous ?

Je n'ai pas compris ta proposition :
"Une autre amélioration que tu peux ajouter c'est que l'arduino vide le buffer de la communication série et n'utilise que le dernier message complet (elle pourrait donc passer des trames)."

Bonne nuit,
Philippe

Bonjour,
Nos élèves peuvent maintenant mettre en mouvement notre bras robotisé basé sur le Moveo.
Nous commandons les mouvements du bras à partir d'un PC qui envoie des consignes (trame de coordonnées articulaires+ouverture de la pince) à une carte Arduino par le port série (usb). Cette carte commande la rotation des axes motorisés (moteurs pas-à-pas) et la pince.

Malheureusement, nous constatons des arrêts ou des ralentissements lors de plusieurs mouvements (trames) successifs.

Nous avons confié au PC les "calculs complexes" et le programme sur Arduino utilise la fonction CASE.

Est-ce la bonne méthode ?

Cette fonction CASE permet aussi de stopper le bras par l'appui d'un bouton sur le PC.

Si j'ai bien compris, l'usage du "case" impose de :
- soit calculer le temps de mouvement entre deux positions (traitement des données par l'arduino plus mouvement du bras) et ainsi de permettre au PC de ne pas envoyer de trames trop rapidement,
- soit envoyer une information "traitement terminé" de l'arduino au PC pour permettre au PC d'envoyer une nouvelle trame sans empiéter sur la précédente.

Est-ce que j'ai bien compris ?

Dans ce cas, ne serait-il pas judicieux de créer une pile FIFO que le PC remplirait et que l'arduino viderait au fur et à mesure des différentes trames traitées ?

Merci de me donner votre point de vue car j'ai très peu de connaissance en informatique et en programmation.

Bonne soirée,
Philippe

Merci Sandro pour ces conseils et idées/solutions très détaillées.

Je vais éviter l'alim de PC avec les élèves.

Je vais essayer un chargeur USB en coupant un cable USB et en récupérant le 5V pour mon servo.

Si je détecte des problèmes de court-circuit avec le câble USB, j'utiliserai 4 piles AAA.

 

Encore merci à tous !!!

Merci Oracid,
Je dois utiliser une carte Arduino UNO car nous en avons plusieurs au lycée.

 

Est-ce que je peux utiliser une alimentation de PC de récupération pour alimenter d'un coté la carte arduino et de l'autre, le servo ?

 

Bonne soirée,
Philippe

Bonsoir,

Merci pour vos conseils, mais cela ne m'arrange pas du tout !! ;-)

Je n'ai qu'une alimentation 12v qui convient bien à mon Arduino, mais qui ne convient pas à mon servo moteur DS3218mg (4.8-5.6V).

 

Philippe
 

Merci Oracid pour tes conseils.

Cette video est très intéressante.

 

Est-ce que je protège mon Arduino et ma prise USB si j'alimente l'Arduino avec une alimentation extérieure en 12V ?

 

Est-ce que c'est c'est normal que le servo de ma pince de robot "tremblote" quand je serre un objet ?

 

Philippe

Bonjour,

Merci à tous de prendre le temps de m'aider.

 

Melmet, pour l'instant, je programme à partir de l'IDE Arduino.

Le scratch, ce sera pour plus tard quand j'aurai enfin réussi à faire bouger ce  de servo...

 

J'alimente ma carte Arduino UNO uniquement avec une prise USB.

Le fil noir est branché sur le GND de la carte

Le rouge sur le 5V de la carte,

Le jaune sur une des sorties digitales PWM (ici la 4)

 

Oracid, j'ai transféré ton programme et il fonctionne parfaitement avec le mini servo 9g.

J'ai retrouvé un second servo DS3218MG. Seul la couleur des fils les différencie l'un de l'autre (marron-rouge-jaune pour le premier et noir-rouge-blanc pour le second).

 

Lorsque je les branche à la place du servo 9g :

- le premier tourne en continu,

- le second ne bouge pas, mais je sens quelques soubresauts en le prenant dans ma main.

 

En changeant de prise USB :

- le premier tourne en continu,

- le second fonctionne normalement.

 

J'en conclu que :

- mon premier servo DS3218MG tout neuf est défaillant,

- suivant le type de prise USB (USB2, USB3 ??), il peut y avoir un problème d'alimentation (pas assez de courant ?).

 

Qu'en pensez-vous ?

Philippe

Bonsoir,
Merci pour la rapidité de votre réponse.

Voici le lien :

www.amazon.fr/gp/product/B07FT8S623/

 

Comment savoir si il s'agit d'un servo à rotation continue ?

 

Philippe

Bonjour,
 

Grand débutant en électronique et programmation.

Pour réaliser une petite activité de découverte de la robotique-mécatronique à des élèves de 4eme en décrochage scolaire, je voulais leur faire faire un petit programme sous scratch et ainsi commander la pince de notre robot avec nos Arduino UNO.

 

C'est mal parti : je n'arrive même pas à commander un servo DS3218MG.

Quand je branche un mini servo 9g (A0090) tout va bien et il répond à mes ordres. Quand je branche le DS3218MG, il tourne en continu...

 

Pouvez-vous m'aider s'il vous plait ? Quelle est la particularité de ce DS3218MG ? Est-il défaillant ? l'ai-je mal connecté (il y a que trois fils...) ?

 

Bonne soirée,
Philippe

Bonjour,

Que voulez-vous faire de ce bras ?

 

Je suis un amateur.
De notre coté, nous avons abandonné la commande par ramp 1.4 (j'avoue que je ne comprends pas l’intérêt).

Nous commandons maintenant le bras, ses 7 moteurs pas-à-pas et sa pince directement avec la librairie AccelStepper sur un arduino mega.

 

Cordialement,
Philippe

Bonjour,

Je suis nul en soudure et en elec ! :-(
A propos des drivers, c'est beaucoup plus clair pour moi.

 

Ce qui me va permettre de choisir le driver sera :

- la plage de tensions d'alimentation : alimentation en 12V pour l'instant.

- le courant max pour mes stepper (17HS15-1504S-X1, 23HS32-4004S, 17HS19-1684S-PG5, 17HS15-1684S-PG5, 14HS13-0804S-PG5, 14HS13-0804S).

- les possibilités de micro-pas qui semblent réduire le bruit de fonctionnement des stepper qui peut être très gênant.

- la connectique : plutôt borniers à vis pour éviter les soudures.

 

Encore merci pour tes réponses !!!!!

Bonjour,
Tu as raison, en comparant le prix d'un shield au prix de l'ensemble, c'est raisonnable. Le problème est que nous avons utilisé tout le budget et nous devrons attendre la rentrée pour faire une demande. Alors, on se débrouille...

 

Merci pour ton conseil : "soudure + gaine thermo-rétractable".

 

Encore une question :

Nous avons pris 7 drivers TB6600 sans trop savoir pourquoi.

Rien que sur le site Robot-maker.com, il y a des drivers de 3.6 € à 72 € !!

Peux-tu m'éclairer sur les critères de choix d'un driver ?

Dans notre cas, nous utilisons des Nema 14, 17 et 23, avec et sans réducteur.

 

Bonne journée,
Philippe

J'ai enfin retrouvé la procédure pour joindre des fichiers !!

Sandro, voici une photo de ma carte Mega et des connections actuelles.

 

Bonne soirée,
Philippe

Merci beaucoup Sandro pour ton aide et cette réponse très précise et documentée !!
Je comprends mieux maintenant ce qu'il est possible de faire.
L'idéal serait un shield avec des borniers, mais ce n'est pas dans notre budget.
Je pense que nous allons utiliser les connecteurs JWT pour relier les drivers à la carte Mega.
 
Les câbles des moteurs pas-à-pas sont trop courts et nous souhaitons les prolonger. Est-ce qu'il existe des connecteurs 4 fils "verrouillables" ?
 
Bonne soirée
Philippe

Bonsoir,

Il s'agit en effet des TB6600
Ils y en a 7 qui seront commandés chacun par 3 fils venant de l'arduino Mega. Je souhaiterais coonecter ces 7x3=21 fils à l'arduino Mega "proprement", solidement et durablement. Existe t'il des connecteur à sertir ou à souder sur ces fils qui s' adaptent à l'arduino ? Sinon, à quoi pourrait ressembler un PCB ?

Bonne soirée,
Philippe

Bonsoir,
Il s'agit du bras Moveo avec un sixième axe. La commande par PC utilise Pythagore généralisé pour déterminer les déplacements articulaires à partir des déplacements en XYZ.
De quelles photos avez vous besoin pour illustrer mon problème de connection solide et durable de câble sur une carte Arduino ?

Cordialement,
Philippe

Bonjour,
Notre projet avance et nous arrivons à commander le bras 6 axes à l'aide d'un PC par une commande articulaire et aussi opérationnelle.
Nous avons des problèmes maintenant de connections électriques : comment relier fermement et durablement les câbles venant des drivers à l'arduino Mega ?
Pouvez-vous nous conseiller svp ?

Philippe

Bonjour Kristoff,
Whaou !! beau boulot.
 

Ta main semble très bien conçue. J'ai hâte de la voir bouger.

Pourquoi faut il que tu développes une "carte électronique "maison" pour servir de shield a un arduino MEGA 2560" ?

 

 

De notre coté, grâce à Mike118, nous avons avancé sur la commande du bras Moveo 6 axes.

En effet, nous travaillons sur le bras avec des élèves. Tout est très lent, mais nous avançons.

Nous gérons assez bien les deux bouts de la chaine : la commande et la partie mécanique.

Notre problème, c'est que nous ne connaissons rien à la partie Elec...

 

Peux-tu m'en dire davantage sur les modifications que tu as effectuées sur le bras Moveo ?

 

A+

Philippe

Merci beaucoup, je vais essayer cette modification dès que possible.

 

Bonne soirée et à bientôt,

Philippe