Bonjour,

Je vais donc commander un teensy 4.0.

Je vais y fixer 2*24 broche femelle (pour que ça ressemble à l'Arduino)

Et 5 broches males pour y fixer un port série supplementaire. 

Mais j'ai besoin de ce cable

https://www.pjrc.com/store/cable_usb_host_t36.html

Est ce si je denude un cable usb et que je soude 5 fils Dupont, je pourrais avoir la même chose?

Aussi pensez vous qu'en overlockant l'Arduino, si c'est possible, je gagnerai significativement en vitesse d'execution. Merci à vous.

2) remplacer la libraire AccelStepper par quelque chose de plus rapide. Soit :

- une autre librairie (il faudra chercher ce qui existe)

- soit ça peut être une implémentation maison, ce qui présente l'avantage qu'on peut enlever tout le "superflu" qui ne sert pas dans ton utilisation. La difficulté et l'efficacité dépendent de ce que tu veux faire précisément (par exemple, si tu n'as pas besoin de gestion de l'accelération mais qu'un controle en vitesse constante suffit, ça simplifie bien les choses)

 

Bonjour Sandro,

Je me disais que si c'était possible et pas trop compliqué d'implementer une librairie maison où l'on a pas besoin de faire varier l'acceleration et la vitesse et que par ce biais on pourrait gagner entre 50 et 100 % de "l'actualisation" de la commande stepper.run, et donc gagner en vitesse entre 50 et 100%, alors je préférais vous donner 30 euros pour ce travail plutôt que d'acheter une carte Tensy.   Bien qu'elle ait des performances impressionnantes... Mais j'ai peur de souder, cabler, reprogrammer... Et que ça me prenne un temps long.   

Avec 1 moteur, j'ai le meme résultat qu'avec 5

En fait, je gère 10 différentes positions avec Processing. Et si l'écart entre la position de chaque moteur est grand, alors la vitesse de chaque moteur est grande.

J'ai pas besoin de faire varier l'acceleration. Ce que j'aimerai c'est qu' a grande vitesse, 3200 step. s, on puisse modifier un peu la position (donc la vitesse un court instant) de chaque moteur afin de voir un décalage de phase entre chaque moteur. Qu'ils restent à cette position tout en allant à la mê^me vitesse afin de voir une spirale.  Et qu'on puisse les aligner afin que la spirale se transforme en un cercle. 

Je vous mets une video pour donner un example du mouvement general.

https://www.youtube....h?v=NGRp7gvnmgg

Avec une acceleration à 1200 pas.s

Dans le premier cas avec 10 moteurs, ils mettent 18 sec à faire les 20 tours 

Avec 5 moteurs , ils mettent 13 sec à faire les 20 tours.

Avec une acceleration à 3200 pas.s

Dans le premier cas avec 10 moteurs, ils mettent 15 sec à faire les 20 tours 

Avec 5 moteurs , ils mettent 11 sec à faire les 20 tours.

Voilà...

Merci encore.

J'ai fait le test 1, mais ça n'a rien changé. 

Voila comment j'ai mis les moveTo

void loop() { 
 
   recvWithStartEndMarkers();  // receive 33 datas from Processing 30 times/sec. 
   
    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(); //  split the 33 data into its parts

           stepper[9].moveTo(PC0);
           stepper[8].moveTo(PC1);
           stepper[7].moveTo(PC2);
           stepper[6].moveTo(PC3);
           stepper[5].moveTo(PC4); 
           stepper[4].moveTo(PC5);
           stepper[3].moveTo(PC6);
           stepper[2].moveTo(PC7);
           stepper[1].moveTo(PC8);
           stepper[0].moveTo(PC9);  
         
        showPosition(); // These datas are used to control positions of 10 motors. Print them on the native port
        showPhazisScaled(); // Print datas on the native port
        showTrigBangWithRevolution(); // Print datas on the native port
       
        newData = false;
    }
 
        // Where can I lighten my program so that it sends the information of postions quickly?
       
       stepper[9].run();        
       
       stepper[8].run();       
        
       stepper[7].run();
       
       stepper[6].run();
         
       stepper[5].run();
       
       stepper[4].run();
      
       stepper[3].run();     
        
       stepper[2].run();
       
       stepper[1].run();
    
       stepper[0].run(); 
}

Aussi, j'ai voulu tester le contrôle comme vous avez dit mais en micro-pas/s.

J'ai tester à deux tours/s, soit 3200 step/s.

Quand je mets les 10 moteurs, je vais un peu plus vite que 1 tour/s.

Et quand je mets 5 moteurs, ils vont bien à 2 tours/s.

Bonne soirée.

Benjamin

Le programme du 3 essai ci dessous

void loop() {   
//PC0=1*millis()/1000/1;    //===>1 pas/s
// Mes moteurs en 1/8 step font 8*200==>1600 step/ tour. 
 
PC0=3200*millis()/1000/1;    //===>3200 pas/s ==> 2 tours/s
PC1=PC2=PC2=PC4=PC5=PC6=PC7=PC8=PC9= PC0;

Serial.println (PC0);

       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[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();
   
 
}

Hello Sandro, 

Merci de répondre si vite. ça me réconforte beaucoup.

J'ai mis les moveTo et run dans la loop comme ça

void loop() { 
 
   recvWithStartEndMarkers();  // receive 33 datas from Processing 30 times/sec. 
   
    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(); //  split the 33 data into its parts  
       
        
        // Where can I lighten my program so that it sends the information of postions quickly?
        // Where I have to repeat the command below or to alight my program ?

        
       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();

        showPosition(); // These datas are used to control positions of 10 motors. Print them on the native port
        showPhazisScaled(); // Print datas on the native port
        showTrigBangWithRevolution(); // Print datas on the native port
       
        newData = false;
    }
 }

Malheureusement ça fait bugger l'ensemble des moteurs qui avance très lentement. 1°/s.

Par contre, le deuxieme test est concluant !!!

Quand j'ai commenté 5 moteurs dans la loop comme ça

void loop() { 
 
   recvWithStartEndMarkers();  // receive 33 datas from Processing 30 times/sec. 
   
    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(); //  split the 33 data into its parts  
         
        showPosition(); // These datas are used to control positions of 10 motors. Print them on the native port
        showPhazisScaled(); // Print datas on the native port
        showTrigBangWithRevolution(); // Print datas on the native port
       
        newData = false;
    }
 
        // Where can I lighten my program so that it sends the information of postions quickly?
         
       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();
 */

}

Les moteurs vont exactement deux fois plus vites. Soit 2 tours/s. Ce qui est bien pour l'aspect visuel de mon installation. 

Néanmoins, j'ai absolument besoin de commander les 10 moteurs.

Dernièrement, pour votre dernier test, si j'enlève la partie réception données, je sais pas comment  "utiliser à la place un petit calcul rapide".

Pourriez vous le programmer pour moi?

Bien à vous

Bonsoir à tous,

J'envoie via Processing, 33 données 30 fois par seconde à la carte Arduino via le Programming Port.

J'ai besoin d'avoir 1600 pas/tour pour tirer au mieux la puissance des moteurs pas à pas NEMA 17 qui font 200 pas/ tour en mode pas complet.

J'ai donc réglé drivers DRV 8825 à 1/8 de micro stepping. Car 8*200=1600.

Sauf qu'avec ce réglage, à partir de 2000 step/sec, les moteurs ne dépassent pas les 1.25 tours/s.

Alors qu'avec un réglage de 1/4 step, soit 800 pas/ tour les moteurs vont bien plus vites, les accélérations sont bien plus saillantes, mais je perds en précision (les moteurs décrochent un peu), et le bruit est assourdissant ( pas génial pour une installation artistique).

Alors, j'imagine que la carte Arduino Due n'arrive plus à envoyer des informations de positions différentes au delà des 2000 step/sec. 

Voilà une  ancienne video où les moteurs suivent l'animation de Processing en mode pas complet (200 step/tour), sans micro stepping 

https://www.youtube....h?v=vQy5JVuKP6Q

Et le programme Arduino

Il y a ce servo moteur avec un couple de 60 kg.cm

J'espère  (en le trafiquant et si c'est simple) qu'il peut peur faire des rotations continues et pas seulement des va et vient.

https://fr.aliexpres....4abd7795LqXgMf

Si non y a celui là 15 kg.cm

https://fr.aliexpres...8#2717#7562#440

Oups, vous avez raison, c'est bien 3.5 N.m.

Avec cette barre de 500g de 1 mètre, si je rajoute une masse de 100g au bout, j'ajoute le CM

 Cm_min=m*r²*acc_inst + r*m*g = m*r*(r*acc_inst + g)=0.1*1*(1*2*3.14 + 9.81)= 1.609 N.m

Au total, j'aurai besoin d'un couple de 5.109 N.m, soit deux fois moins que le couple du dît moteur  11.76 N.m.

Là, je pense n'avoir pas de mauvaise surprise...  

Merci  

D'après votre dernière formule, si je mets une barre de 500g de 1 metre, je trouve 2.62 N.m. Ce qui est bien moindre.

Mais pourquoi vous divisez la longueur de la barre par 1/3 au debut de la formule et 1/2 ensuite ?

Et pour finir, si je rajoutais une masse de 100 grammes au bout de cette barre, que deviendrait la formule?

Et j'arrête de vous embêtez....

Precision super precise, merci beaucoup Sandro. 

Du coup, je profite de vos bons conseils pour vous en demander un dernier. J'ai un driver drv8825 pour moteur pas à pas. https://www.pololu.c...duct/2133/specs

Je pense malheureusement pas qu'il soit réglable pour utiliser deux bobines en même temps. Mais peut -être que oui?

Aussi, j'ai trouvé ce moteur puissant https://www.ebay.co....r-/192424248398.

Ses caractéristiques sont:

Material: Metal

Color: As Pictures Shown
Dimensions: Overall About 4.2 * 4.2 * 3.4cm
Line Length: About 31cm
Motor Type: 17HS1352-P4130
Voltage: 12V-24V
Current / Phase: 1.33A
Resistance / Phase: 2.1Ω
Inductance / Phase: 2.5mh
Static Torque: 2.2kg-cm
Outlet: 4-Wire
Inertia: 35g-cm²
Location Torque: 120kg-cm

120 kg.cm équivaut à 120000 g.cm soit 3 fois plus puissant. Ou encore 11.76 N.m. Par contre il consomme 2.1 Ampere, je devrais refroidir les drivers avec un grand ventile et les moteurs avec un simple dissipateur couplé à  un ventilateur j'imagine.

Avant de l'acheter, je voulais savoir si 3 * plus puissant voulait dire que je pourrais augmenter les caractéristiques de la barre:

D'après votre formule:  Cm_min=m*r²*acc_inst + r*m*g = m*r*(r*acc_inst + g)=0.2*0.08*(0.08*2*3.14 + 9.81)= 0.165 N.m

Avec une masse de la barre en acier qui  ferait 500g et mesurerait 1 m : 0.5*1*(1*2*3.14 + 9.81)=  .5*16.09= 8.45N.m

Théoriquement ça devrait aller, non?

Merci Sandro,

J'essaye que mes moteurs répondent de manière quasi instantanée aux différentes positions (phases) que je leur donne avec Processing.

Donc, le choix de l'accélération est bonne: acc_inst=1 tr/s²

En convertissant (grace à un site) 0.165 N.m-1, j'obtiens 1682,5317514135352 g.cm-1

Sur la doc, mes NEMA 17 ont un couple de 4000 g.cm

Mais au bout de quelques temps, ils décrochent de leur position. (de pas beaucoup, mais un moteur perd sa position au bout de 30 sec)

J'ai augmenté la puissance des drivers de 1.5  à 2 Amperes, mais ça change pas grand chose, à part que les moteurs chauffent.

Est ce que je devrais rapprocher le moyeu, le plus près de la surface de la "base" du moteur. Le passer de 2 à 1 cm?

Devrais je mettre la barre en metal au milieu?

Ou est ce que dans la doc, les 4000g.cm signifient autres choses?

Merci encore Sandro.

Spécifications:

Nom du produit: 17 moteur pas à pas

Numéro de modèle: 17HS4401

Matière: Métal

Couleur: argent & noir

Précision de l'angle de marche: +-5% (pas complet, pas de charge)

Précision de résistance: +-10%

Précision d'inductance: +-20%

Montée en température: 80 ° Max (courant nominal, 2 phases allumées)

Température ambiante:-20 ° ~ + 50 °

Résistance d'isolation: 100MΩ Min, 500VDC

Force d'isolation: 500VAC pendant une Minute

Phase: 2

Tenir le Couple: 4000 g.cm

Courant/Phase: 1.5A

Angle de marche (degrés): 1.8

Tension: 12 V-24 V

Bonjour la communauté.

Je fais tourner des moteurs en fonction des positions données par Processing

https://www.youtube....h?v=5zvXvy1V4bA

J'essaye de calculer le couple d'un moteur pour faire tourner une barre de 8 cm et de 0.2 Kg fixée en son bout à un moteur pas à pas.

J'aimerais qu'il aille à 3 tours/s et qu'il ait une accélération d'au moins 1/2 tours .s-2 et au mieux 1 tours. s-2

Je me suis basé sur ce cours: https://www.robot-ma...ur-votre-robot/

A 3 tours /s, la vitesse de la barre rayon .08 mètres est de 3*2PI*R= 3*2*PI*0.08=1.51 m.s-1

Je calcule seulement la force cinétique car je ne suis pas sur un plan incliné.

Force Moteur= 1/2 m * (v(t)^2-v(0)^2);   F =  1/2*0.2 *1.51* (1.51^2-0) = .23 N.m-1

Le couple moteur Cm est égale  = Force Moteur*rayon = 0.23 * 0.08 = .0184 N.m-1

Après je sais plus comment on intègre la principe de la dynamique pour trouver le couple en fonction de l'acceleration.

En fonction de la réponse, j'aurai besoin de savoir quel moteur acheté et s'il serait pas mieux d'utiliser des moteur avec des encodeurs plutôt que pas à pas

Merci pour votre aide

Bonjour à tous,

Je pilote pour le moment 4 NEMA 17  consommant 1.5 A, 12V. Ceux-ci Nema 17 step motor 42BYGH 17HS4401

J'ai bien reglé mes drivers DRV8825 avec le potar intégré  à Vref = 0.75 V car la puissance à délivrer est de 1.5 A. Se calculant  Vref= I max/2 --> 0.75= 1.5/2

J'ai une alimentation  à "hachage" 12V, 20A. Elle alimente les 4 drivers (4*2 Dupont reliés à deux gros fils sortant de l'alimentation) qui sont fixés à la breadboard.

Quand je fixe un moyeu et une barre en acier plate de 12 cm (une équerre plate), le tout pèse 100 grammes je pense, les moteurs décrochent, alors qu'ils fonctionnent à vide. Ces moteurs suivent les positions envoyées par Processing et ne dépasse pas les 1 tour/s, soit 200 pas/s.

Pensant que c'est un problème de surtension qui passe dans la breadboard, faut 'il acheter un kit de blindage CNC,  des supports de driver séparés, un kit de rampe pour imprimante (je sais pas trop ce que c'est) ou ça n'a rien  voir avec la breadboard ou la sur-tension? 

Au final, j'aimerai piloter 12 moteurs en même temps. merci pour vos avis et conseils    

Hello Jo,

Je viens de faire un test avec des differences de 4+i avec une vitesse de 26 pour le moteur 0.

En théorie au bout d'une minute les moteurs devraient avoir fait 26, 30, 34, 38 et 42 tour en une minute.

Au bout de 30 secondes exactement(sans rajouter  une 1/2 seconde) , elles sont bien toutes sur leur point de départ, donc bien alignées. (si on chipote pas).

Mais au bout d'une minute exactement, celle du  moteur 0 est parfaitement sur son point de départ , celle du moteur 1 quasiment sur axe de départ, mais la 2, 3 et 4 ont respectivement 0.08, 0.16 et 0.25 tour de retard.

Au bout de deux minutes exactement, l'écart se creuse encore plus entre les helices.

Bien que le moteur 0 a exactement fait 52 tours, alors qu'on aurait pu croire qu'il aurait eu du retard, si on se base par rapport au test d'avant, ou le moteur 4 n'a pas réussi a faire ses 42 tours exactement!! .

Les moteurs 1, 2, 3 et 4 ont respectivement 0.08, 0.25, 0.32 et 0.5 tour de retard. (à peu près)

J'espere que ça t'éclaire, il doit y avoir un truc simple, mais je sais pas où.

Merci à toi

Voilà les vidéos avec des bpm de 20+ (1*i) et 20+ (4*i) sur 30 secondes

et la vidéo de 20+ ( 1*i) sur 2 min.

1er cas:  20+(4*i) : Avec des vitesses de 4 bpm  de différence (20, 24, 28...).

Au bout de 30 sec, Les 5 helices s'arrêtent aux bons nombres de tours et donc dans le même axe de départ.

Elles ont fait 10, 12, 14... tours.

Pour être bien calé sur le bon nombre de tours, j'ai rajouté une demi seconde. Sinon,

elles ne se sauraient pas remises sur l'axe de départ, elles seraient un peu en arrière, mais quasi alignées.

2 ème cas: 20+(1*i) : Avec des vitesses de 1 bpm de difference (20, 21, 22...).

Au bout de 30 sec+ 1/2 sec comme rajouté ci dessus, elles ne sont pas alignées, alors qu'elles auraient du faire

10, 10.5, 11, 11.5 et 12 tours. Et donc être calés d'un demi-tour.

On voit bien que la premiere et la cinquième sont à leur place (un peu en avant / à l'axe de départ),

mais pas les autres. C'est bizarre.

Dans le 2 ème cas, quand on généralise a d'autres vitesses comme 18+ (1*i) ou 16+ (1*i),  ce qui est étrange c'est que les premiere et cinquième helices sont toujours alignés!!! Elles arrivent dans la même position, alors que c'est pourtant celles qui ont le plus de différence de vitesse !  

Avec les mêmes vitesses que ci dessus sur deux minutes, on observe qu'elles ne sont pas calés du tout.

J'ai multiplié par 4, les 30,5 secondes de ci-dessus, on a donc deux minutes et deux secondes.

On voit que la premiere et cinquième sont bien en haut, sur leur axe, mais pas les autres. 

La cinquième hélice a fait 48 tours et la premiere 40. Comme demandé par leur programme (auquel, j'ai du rajouté 2 secondes quand même!!).

Mais les autres ont fait:

la 4eme a fait 45.25 au lieu de 46.

la 3eme a fait  43.25 au lieu de 44

la 2 eme a fait 41.6 au lieu de 42

Le 1er et 2 ème cas sont vrais sur 30 secondes, en remplaçant 20 par 40 ou 60.

Malheureusement si je généralise le premier cas, où les moteurs ont des differences de 4 bpm entre elles,  elles  n'arrivent pas toujours toutes alignées au bout de 30 secondes.

Avec par exemple: 10+(4*i), 18+(4*i), ça ne fonctionne pas. 

Alors qu'elles arrivent alignées avec: 9+ (4*i), 15+ (4*i), 16+ (4*i).  Rappel dans le 2 ème cas, 16+ (1*i), elles ne sont pas alignées, sauf la premiere et cinquième.

Pour 30 secondes, pourquoi,  est-ce plus compliqué de faire 16+ (1*i) que 16+ (4*i)?

Ou alors pourquoi 8 + (1*i) ou 8 + (2*i), les helices ne sont pas alignées,  alors qu'avec 8 + (4+i) elles le sont parfaitement?

Voila, c'est mystérieux et donc pas simple pour moi, de profiter du mouvement simplement..

Bises et bonne année.

Yep.

Voila le programme pour tester le bon calibrage de Nombre de tick / Tour.

Et donc, il faut *100 pour bien les positions (absolue ou relative ) pour avoir le bon nombre de tick / tour.

Puis gérer les autres variables en amont, j'imagine.

Merci à toi.

J'ai testé le programme et il n'y a pas de problème de décalage entre le temps indiqué et le temps réelle.

Par contre je viens de réaliser en traçant les positions de 5 moteurs, que si je mets 63250 ms pour qu'ils fassent bien le bon nombre de tours à l'oeil,  les postions données par le graphique n'étaient pas à 0.

Par contre en mettant 64000, les positions sont toutes à 0.

Du coup, c'est un problème avec les constantes du nombre de tick par tours.

J'ai testé 99 et 100 pour le GEARRATIO

const uint8_t GEARRATIO = 99 ;//100;

Avec 99, il y a 2772 position,/tour. Avec 100, il y a 2800

J'ai testé  et mesuré pour avoir 100 tours exactement à 85rpm. Il faut 70,588 sec.

 Avec 99  il y a 45° à 70° en trop. Les moteurs sont à leur bonne position sur le graphique..

Avec 100 il y a 3/4 de tour en trop; les moteurs apparaissent  à 1600 sur le graphique.

Donc 99 c'est mieux, mais c'est encore un peu trop. 

J'avais sur une fiche technique, qu'il 198.6 impulse/tour . Qu'est ce que çà veut dire?

Sinon, peut -on améliorer la precision avec un nombredetick / tour calculé à la main?

Merci pour ton aide

Yep.

Concernant le décalage de temps que mets la Arduino (un peu trop long de 250 ms) pour avoir le bon nombre de rotation selon le temps réelle. J'ai fait des test à 30, 45,60, 75 et 90 rpm.

Avec toutes ces vitesses, il me faut 15750 ms pour que les moteurs aient fait le bon nombre de rotations. Alors qu'il aurait fallu 16 sec.

Pour faire 4 * plus de tours, j'ai fait 4* 15750 ms = 63000 ms, mais il manquait 30° à tous les moteurs.

Le bon temps, pour le bon nombre de rotation souhaité est de 63250 ms. Alors qu'en théorie il aurait fallu 64 sec.

Donc plus on avance dans le temps, et plus l'Arduino décompte le temps rapidement. Avec une erreur de 750 ms au bout de 64 sec.

Je sais pas comment réglé la machine pour que le temps programmé, soit le vrai temps.

J'ai trouvé sur le forum Arduino, un programme qui recalle le temps, mais je sais pas si c'est assez pour faire tourner la machine une demie heure par exemple sans perdre 1/10 de sec.

J'ai teste le programme ci dessous et j'ai perdu 1/10 de sec  en 2h15. La difference entre le temps affiché dans le serial monitor avec celui de l'horodatage.

// Déclaration des variables et constantes horloge

unsigned long refTemps;              // echeance placee dans le futur

int jour=19;                // Jour de l'horloge
int heure = 18;             // Heures de l'horloge
int minute = 6;            // Minutes de l'horloge
int seconde = 30;            // Secondes de l'horloge


void setup() {

  // Initialise la liaison série
  Serial.begin(19200);

}


void loop() {

  if (millis()>= refTemps){          // si millis est egal ou plus grand que l'echeance

    refTemps+=1000;                   //la derniere echeance + 1 seconde
    seconde++;                      // on additionne 1 seconde

    if(seconde>=60){                // lorsque les secondes arrivent a 60
      minute++;                     // on additionne 1 minute
      seconde=0;                    // et on remet les seconde a zero
      if(minute>=60){               // lorsque les minutes arrivent a 60
        heure++;                    // on additionne 1 heure
        minute=0;                   // et on remet .... etc, etc
        if(heure>=24){
          jour++;
          heure=0;

        }
      }
    }
  }

  // on envoie dans le moniteur serie le jour, l'heure, les minutes et les secondes....
  Serial.print(jour);
  Serial.print("     ");  
  Serial.print(heure);
  Serial.print("     ");  
  Serial.print(minute);
  Serial.print("     ");  
  Serial.println(seconde);
  delay(100);
}

Est ce une solution ? 

Merci

Salut Jonathan,

J'ai refait des tests avec le programme précédent la dernière retouche que t'avais faite.

Avec les consignes pour void yoyo1

setConsigneMoteur(i, (rpm * temps  + (i+2 )* 60) / (float)temps); //   puis

setConsigneMoteur(i, (rpm * temps  + (i-2 )* 60) / (float)temps); // 

Je me suis aperçu qu'en fonction des paramètres de vitesses et de répétions cycles, le programme et donc les pâles ne buggait pas pareillement

Avec yoyo (15,120) le monitor n'affiche plus rien au debut du 3ème cycle. Au bout 1 min 36 sec. On dirait donc qu'elle bugge exactement en debut de cycle

Là ça commence bien au debut, puis on voit le moteur 2 prendre du retard et se synchroniser sur le moteur 1.

Je crois qu'avec mon autre config et avec le void yoyo1 à 50 bpm, j'avais un problème avec l'execution de la 3ème ou 4ème fois que la void yoyo1 se lançait.

Mais la c'est autre chose, c'est avant même qu'elle se replie.

Si t'as un ensemble de test à me faire faire, n'hésite pas.

Dans les deux dernières videos, c'est le même code. Celui que j'ai mis en pièce-jointe.

Je le remets ici une plus propre.

 max_ardui0.1_12V.ino   17,06 Ko   1 téléchargement(s)

Re-salut!

Je mets une video qui sera peut être plus explicite.

Le  motif fonctionne pendant à peu près deux minutes, puis l'hélice du centre, la troisieme sur cinq, la i=2, se décale par rapport aux autres et finie par se synchroniser sur la i=3.

Alors que l'écart devrait être constant du debut à la fin et tourner en boucle.

J'imagine qu'ensuite, la 3 se cale sur la 4, puis la 4 sur 0 et ainsi de suite. Mais je suppose seulement.

Je vérifirais.

Je me disais ensuite qu'il serait peut être interessant, que je choisisse qu'elle se décale les unes par rapport aux autres, à chaque fois qu'un cycle ait été fait.

Merci.

Hello Jo, 

Pour avoir un mouvement plus fluide à l'oeil nu, j'ai pris des moteurs allant jusqu'à 30 tr/min avec ces caractéristiques:

L'extrémité du moteur du codeur 11 signale

Tension d'entrée (V)

12

Ratio de réduction de retardateur

1: 200

Pas de vitesse de charge (RPM)

30

Pas de courant de charge (mA)

≤60

Couple nominal (kg.cm)

10.0 Kg.cm

Vitesse nominale (RPM)

21

Courant nominal (A)

≤0.4

décrochage Torque

≥ 32 Kg.cm

StallCurrent (A)

≤1.0

Résolution Hall

2200

J'ai réglé le timer à 5000 pour m'approcher d'une vitesse de 127 avec un PWM de 127.

Les 5 moteurs sont parfaitement synchronisés ( même vitesse, pas de décalage de phase).

J'ai juste changé la vitesse de rotation dans void loop() {

yoyo1(50, 120); en

yoyo1(20, 120);

et dans le setup () { la ligne:

if(millis() - reftemps > temps * 1000 / 4 en

if(millis() - reftemps > temps * 1000 / 5  car j'ai cinq moteurs et çà fonctionnait mieux comme çà avec l'autre configuration

void yoyo1(double rpm, int16_t temps) {   // temps en secondes

Merci pour ton regard aiguisé.

Voici l'effet de yoyo2.

J'ai changé des réglages.

On voit bien le moteur du fond se déphaser vers l'avant (dans le sens de rotation), puis les autres suivent et le mouvement est joli.

Puis arriver à un certain écart ( déphasage entre les moteurs), on voit un redressement et  pendant un cours instant,

le moteur de devant se déphase vers l'avant (il rattrape son retard) et les autres suivent pour en fin se re-synchroniser en phase.

Puis on revient au départ.

Comment faire pour que après le redressement ce soit le moteur de devant qui soit la reference et non celui du fond?

Dans le case2 à (i +2.5), j'ai essayé de mettre un moins et même juste i, mais ça change rien j'ai aucun changement de motif.

Je comprends pas trop.

Merci, en tous cas, ça s'annonce pas mal! 

void yoyo2(double rpm, int16_t temps) {   // temps en secondes
  static uint8_t etat = 0;
  static uint32_t reftemps = 0;
  
   switch (etat) {
     case 0: 
      if(millis() - reftemps > temps * 1000 / 15) {//4 probleme helice (premiere et derniere vont trop vite) 15 ça va // 1000 car comparaison de secondes avec ms et 4 car quart de tour
       mode = POSITION;
       for(uint8_t i = 0; i < NBMOTEURS; i++) { 
        setConsigneMoteur(i, (rpm * temps  + (i - 2.5)* 60) / (float)temps); // 2.5, 5 OK car multiple de 5 ???;// 4; 20 --> la derniere helice tourne trop vite et saccade; pareil avec autre helice
       } 
       reftemps = millis();
       etat = 1;
      }
    break;
     case 1:
      if(millis() - reftemps > temps * 1000 / 10) { // 1000 car comparaison de secondes avec ms et 4 car quart de tour
       mode = RECALLAGE4;
       reftemps = millis();
       etat = 2; 
      }
    break;
     case 2: 
     
      if(millis() - reftemps > temps * 1000 / 15) {  // 1000 car comparaison de secondes avec ms et 4 car quart de tour
       mode = POSITION;
       for(uint8_t i = 0; i < NBMOTEURS; i++) { 
        setConsigneMoteur(i, (rpm * temps  + (i +2.5) * 60) / (float)temps); // tu avais rien mis à (i +2.5), seulement i, c'est exprès?
       } 
       reftemps = millis();
       etat = 3;
      }
    break;
     case 3:
      if(millis() - reftemps > temps * 1000 / 10) { // 1000 car comparaison de secondes avec ms et 4 car quart de tour
       mode = RECALLAGE0;
       reftemps = millis();
       etat = 0; 
      }
   }
}