Moteur DC et joystick : problème vitesse mini

[Yvan_Delaserge]

Tu as encore une fois raison.

Il y aurait deux manières de corriger le problème:

1) modifier le map
motorSpeedA = map(joyValueA, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
en ceci:
motorSpeedA = map(joyValueA, joyValueMidUpper, joyValueMax, motorSpeedMax, motorSpeedMin);

2) modifier le if
if (millis() >= startDelayA + SpdA)
en ceci:
if (millis() >= startDelayA + 256 - SpdA)

Pour ma part je choisirais plutôt la seconde solution, car elle permet de garder les noms des variables avec leur signification originale.

Rendez-vous au prochain bug!
-----

[davidkings]

Bon, j'ai essayé, ça tourne, mais ça ne fait pas mieux que le code classique (analogwrite), càd que le moteur ne démarre que joystick presque à fond.
Si j'augmente le delay, le moteur tourne moins vite mais avec des à-coups violents.

Petite question : le code, tel qu'il est écrit, arrête le moteur par son inertie ou par un frein ?

[Yvan_Delaserge]

Poste le soft exactement tel qu'il est actuellement. Après toutes ces modifications, il faut tout repasser en revue.

[davidkings]

Voilà le code. Ca marche mais ça fait des acoups violents

//Set pin numbers:
const byte joyStickPinA = A1;
const byte motorSpeedPinA = 5;
const byte motorDirPin1A = 2;
const byte motorDirPin2A = 4;

const byte joyStickPinB = A2;
const byte motorSpeedPinB = 6;
const byte motorDirPin1B = 7;
const byte motorDirPin2B = 8;

//variables
//Joystick input variables
int joyValueA = 0;
int joyValueB = 0;
int joyValueMax = 1023;
int joyValueMin = 0;
int joyValueMid = 512;
int joyValueMidUpper = joyValueMid + 8;
int joyValueMidLower = joyValueMid - 8;
 
//DC motor variables
byte motorSpeedA = 0;
byte motorSpeedB = 0;
byte motorSpeedMax = 255;
byte motorSpeedMin = 150;

unsigned long startDelayA;
unsigned long startDelayB;

int tempo = 8;


void MotorForwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 1);
    digitalWrite (motorDirPin2A, 0);    
    if (millis() >= startDelayA + 255 - SpdA)
    {  digitalWrite (motorSpeedPinA, 1);
       delay(tempo);
       digitalWrite (motorSpeedPinA, 0);
       startDelayA = millis(); // on mémorise le temps courant du chrono    
    }
}

void MotorBackwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 0);
    digitalWrite (motorDirPin2A, 1);    
    if (millis() >= startDelayA + 255 - SpdA)
    {  digitalWrite (motorSpeedPinA, 1);
       delay(tempo);
       digitalWrite (motorSpeedPinA, 0);
       startDelayA = millis(); // on mémorise le temps courant du chrono    
    }
}


void MotorStopA()
{
    analogWrite(motorSpeedPinA, 0); 
}

void MotorForwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 1);
    digitalWrite (motorDirPin2B, 0);    
    if (millis() >= startDelayB + 255 - SpdB)
    {  digitalWrite (motorSpeedPinB, 1);
       delay(tempo);
       digitalWrite (motorSpeedPinB, 0);
       startDelayB = millis(); // on mémorise le temps courant du chrono    
    }
}
 
void MotorBackwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 0);
    digitalWrite (motorDirPin2B, 1);    
    if (millis() >= startDelayB + 255 - SpdB)
    {  digitalWrite (motorSpeedPinB, 1);
       delay(tempo);
       digitalWrite (motorSpeedPinB, 0);
       startDelayB = millis(); // on mémorise le temps courant du chrono    
    }
}
 
void MotorStopB()
{
    analogWrite(motorSpeedPinB, 0);  
}




void setup()
{
    pinMode(joyStickPinA, INPUT);
    pinMode(motorSpeedPinA, OUTPUT);
    pinMode(motorDirPin1A, OUTPUT);
    pinMode(motorDirPin2A, OUTPUT);

    pinMode(joyStickPinB, INPUT);
    pinMode(motorSpeedPinB, OUTPUT);
    pinMode(motorDirPin1B, OUTPUT);
    pinMode(motorDirPin2B, OUTPUT);

    startDelayA = millis();
    startDelayB = millis();
    
    
}
 
void loop()
{
    joyValueA = analogRead(joyStickPinA);
         
    if(joyValueA > joyValueMidUpper) //Forward
    {
        motorSpeedA = map(joyValueA, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardA(motorSpeedA);
    }
    else if(joyValueA < joyValueMidLower) //Backward
    {
        motorSpeedA = map(joyValueA, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardA(motorSpeedA);
    }
    else
    {
       MotorStopA();
    }
    
    joyValueB = analogRead(joyStickPinB);
    
    if(joyValueB > joyValueMidUpper) //Forward
    {
        motorSpeedB = map(joyValueB, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardB(motorSpeedB);
    }
    else if(joyValueB < joyValueMidLower) //Backward
    {
        motorSpeedB = map(joyValueB, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardB(motorSpeedB);
    }
    else
    {
       MotorStopB();
    }
 
}

[davidkings]

Je rajoute que j'ai essayé de donner plusieurs valeurs à la variable "tempo". Si trop faible (>8, le moteur ne démarre pas, on entend des gros clacs), et à partir de 8 ça démarre mais en faisant de gros à coups qui rendent l'image de la caméra inexploitable.

[Yvan_Delaserge]

MotorSpeedMin est à 150. Baisse-le à 1.

[davidkings]

je l'ai mis à 150, c'est la valeur moyenne à laquelle démarre le moteur (en fonction du delay choisi). En dessous on entends de gros clacs mais il ne se passe rien.

[davidkings]

dans le post #35, j'ai écrit >8 au lieu de <8

Sinon, il faudrait revenir à l'idée du PPM, mais mon niveau de programmation n'est pas suffisant.
J'ai trouvé ceci sur le net, c'est un script pour générer un signal PPM sous arduino. Mais je n'y ai pas compris grand chose

Serais-tu capable de l'adapter à mon programme ?

//this programm will put out a PPM signal

//////////////////////CONFIGURATION///////////////////////////////
#define chanel_number 8  //set the number of chanels
#define default_servo_value 1500  //set the default servo value
#define PPM_FrLen 22500  //set the PPM frame length in microseconds (1ms = 1000µs)
#define PPM_PulseLen 300  //set the pulse length
#define onState 1  //set polarity of the pulses: 1 is positive, 0 is negative
#define sigPin 10  //set PPM signal output pin on the arduino
//////////////////////////////////////////////////////////////////


/*this array holds the servo values for the ppm signal
 change theese values in your code (usually servo values move between 1000 and 2000)*/
int ppm[chanel_number];

void setup(){  
  //initiallize default ppm values
  for(int i=0; i<chanel_number; i++){
    ppm[i]= default_servo_value;
  }

  pinMode(sigPin, OUTPUT);
  digitalWrite(sigPin, !onState);  //set the PPM signal pin to the default state (off)
  
  cli();
  TCCR1A = 0; // set entire TCCR1 register to 0
  TCCR1B = 0;
  
  OCR1A = 100;  // compare match register, change this
  TCCR1B |= (1 << WGM12);  // turn on CTC mode
  TCCR1B |= (1 << CS11);  // 8 prescaler: 0,5 microseconds at 16mhz
  TIMSK1 |= (1 << OCIE1A); // enable timer compare interrupt
  sei();
}

void loop(){
  //put main code here
  static int val = 1;
  
  ppm[0] = ppm[0] + val;
  if(ppm[0] >= 2000){ val = -1; }
  if(ppm[0] <= 1000){ val = 1; }
  delay(10);
}

ISR(TIMER1_COMPA_vect){  //leave this alone
  static boolean state = true;
  
  TCNT1 = 0;
  
  if(state) {  //start pulse
    digitalWrite(sigPin, onState);
    OCR1A = PPM_PulseLen * 2;
    state = false;
  }
  else{  //end pulse and calculate when to start the next pulse
    static byte cur_chan_numb;
    static unsigned int calc_rest;
  
    digitalWrite(sigPin, !onState);
    state = true;

    if(cur_chan_numb >= chanel_number){
      cur_chan_numb = 0;
      calc_rest = calc_rest + PPM_PulseLen;// 
      OCR1A = (PPM_FrLen - calc_rest) * 2;
      calc_rest = 0;
    }
    else{
      OCR1A = (ppm[cur_chan_numb] - PPM_PulseLen) * 2;
      calc_rest = calc_rest + ppm[cur_chan_numb];
      cur_chan_numb++;
    }     
  }
}

[davidkings]

oups : c'est PFM au lieu de PPM donc mon exemple de code ne sert pas

[Yvan_Delaserge]

je l'ai mis à 150, c'est la valeur moyenne à laquelle démarre le moteur (en fonction du delay choisi). En dessous on entends de gros clacs mais il ne se passe rien.

Il faut OBLIGATOIREMENT mettre MotorspeedMin à 1 autrement la vitesse minimale du moteur ne sera jamais obtenue! Ce que tu veux, c'est des moteurs qui tournent lentement, pas qui passent directement à 150.

Avec Motorspeedmin à 1 ( c'est-à-dire lorsque le joystick est proche de sa position de repos) on devrait avoir des impulsions à 4 Hz environ (une impulsion toutes les 250 ms).

Ensuite, il s'agit de déterminer quelle est la durée minimale des impulsions qui font réagir le moteur. Tu avais perlé de 5 ms au début, puis de 8 ms.

Une manière simple de contrôler les impulsions produites par le montage serait de brancher une LED avec une résistance en série de 330 ohms, aux sorties du shield (en s'assurant que la polarité de la LED soit OK).

Sinon, si tu n'as pas d'oscilloscope, il existe des programmes utilisant la carte-son du PC qui permettent d'utiliser ce dernier comme un oscilloscope. Par exemple celui-ci:

Dès que j'aurai un peu de temps, il faudra aussi que je modifie un peu le programme pour qu'il produise les impulsions sans faire appel à la fonction delay() parce qu'il s'agit d'une fonction bloquante. Le microcontrôleur ne fait rien d'autre pendant qu'il exécute delay(), ce qui peut faire interférer l'un avec l'autre les signaux envoyés aux moteurs.

[Yvan_Delaserge]

En observant à l'oscilloscope les signaux produits par la dernière version du soft, qui utilise delay(), on voit qu'un canal influence l'autre lorsqu'il produit des impulsions très rapprochées. C'est normal, plus un canal produit d'impulsions par seconde, plus souvent il utilise delay() pour les produire et plus il accapare du temps processeur.
Si on a les deux potentiomètres à fond, on voit que les impulsions de 8 ms sont séparées par des intervalles de même durée. Le processeur partage son temps équitablement entre les deux canaux. Mais cela signifie que les moteurs ne reçoivent qu'un signal de rapport cyclique de 50%.
Ou alors, un moteur peut recevoir des impulsions très rapprochées, il sera alors à un rapport cyclique de 95% environ, mais l'autre moteur devra alors être presque à l'arrêt.

Pour éviter ce défaut, voici le soft sans utilisation de delay().

//Set pin numbers:
const byte joyStickPinA = A1;
const byte motorSpeedPinA = 5;
const byte motorDirPin1A = 2;
const byte motorDirPin2A = 4;

const byte joyStickPinB = A2;
const byte motorSpeedPinB = 6;
const byte motorDirPin1B = 7;
const byte motorDirPin2B = 8;

//variables
//Joystick input variables
int joyValueA = 0;
int joyValueB = 0;
int joyValueMax = 1023;
int joyValueMin = 0;
int joyValueMid = 512;
int joyValueMidUpper = joyValueMid + 8;
int joyValueMidLower = joyValueMid - 8;
 
//DC motor variables
byte motorSpeedA = 0;
byte motorSpeedB = 0;
byte motorSpeedMax = 255;
byte motorSpeedMin = 1;

unsigned long startDelayA;
unsigned long startDelayB;

int tempo = 8;

void setup()
{
    pinMode(joyStickPinA, INPUT);
    pinMode(motorSpeedPinA, OUTPUT);
    pinMode(motorDirPin1A, OUTPUT);
    pinMode(motorDirPin2A, OUTPUT);

    pinMode(joyStickPinB, INPUT);
    pinMode(motorSpeedPinB, OUTPUT);
    pinMode(motorDirPin1B, OUTPUT);
    pinMode(motorDirPin2B, OUTPUT);

    startDelayA = millis();
    startDelayB = millis();
    
    
}
 
void loop()
{
    joyValueA = analogRead(joyStickPinA);
         
    if(joyValueA > joyValueMidUpper) //Forward
    {
        motorSpeedA = map(joyValueA, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardA(motorSpeedA);
    }
    else if(joyValueA < joyValueMidLower) //Backward
    {
        motorSpeedA = map(joyValueA, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardA(motorSpeedA);
    }
    else
    {
       MotorStopA();
    }
    
    joyValueB = analogRead(joyStickPinB);
    
    if(joyValueB > joyValueMidUpper) //Forward
    {
        motorSpeedB = map(joyValueB, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardB(motorSpeedB);
    }
    else if(joyValueB < joyValueMidLower) //Backward
    {
        motorSpeedB = map(joyValueB, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardB(motorSpeedB);
    }
    else
    {
       MotorStopB();
    }
 
}

void MotorForwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 1);
    digitalWrite (motorDirPin2A, 0);    
    if (millis() >= startDelayA + 255 - SpdA)
    {  digitalWrite (motorSpeedPinA, 1);
       if (millis() >= tempo + startDelayA + 255 - SpdA)
              {digitalWrite (motorSpeedPinA, 0);
               startDelayA = millis(); // on mémorise le temps courant du chrono    
               }
    }
}

void MotorBackwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 0);
    digitalWrite (motorDirPin2A, 1);    
    if (millis() >= startDelayA + 255 - SpdA)
    {  digitalWrite (motorSpeedPinA, 1);
       if (millis() >= tempo + startDelayA + 255 - SpdA)
              {digitalWrite (motorSpeedPinA, 0);
               startDelayA = millis(); // on mémorise le temps courant du chrono    
               }
    }
}

void MotorStopA()
{
    analogWrite(motorSpeedPinA, 0); 
}

void MotorForwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 1);
    digitalWrite (motorDirPin2B, 0);    
    if (millis() >= startDelayB + 255 - SpdB)
    {  digitalWrite (motorSpeedPinB, 1);
       if (millis() >= tempo + startDelayB + 255 - SpdB)
              {digitalWrite (motorSpeedPinB, 0);
               startDelayB = millis(); // on mémorise le temps courant du chrono    
               }
    }
} 
void MotorBackwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 0);
    digitalWrite (motorDirPin2B, 1);    
    if (millis() >= startDelayB + 255 - SpdB)
    {  digitalWrite (motorSpeedPinB, 1);
       if (millis() >= tempo + startDelayB + 255 - SpdB)
              {digitalWrite (motorSpeedPinB, 0);
               startDelayB = millis(); // on mémorise le temps courant du chrono    
               }
    }
} 
void MotorStopB()
{
    analogWrite(motorSpeedPinB, 0);  
}

Après avoir démarré une impulsion, on se réfère de nouveau à millis() pour savoir à quel moment il faut stopper l'impulsion.

Avec ce soft, on peut maintenant atteindre des rapports cycliques de plus de 90% simultanément avec les deux moteurs.

Ce que l'on constate, c'est que pour les faibles déplacements du joystick, la puissance envoyée au moteur croît très lentement d'abord, puis très vite lorsque le joystick est presque en fin de course.

Pour avoir un fonctionnement plus proche de celui de la version monomoteur du soft, on peut calculer l'intervalle entre les impulsions non plus par 255 - SpdB, respectivement 255 - SpdA mais par 1 / SpdB, respectivement 1/ SpdA.
On obtiendra ainsi quelque chose qui sera proportionnel à la fréquence ( f = 1/période).
Il faudra trouver par quel coefficient multiplier l'inverse de SpdA et SpdB et quel coefficient additionner pour arriver aux valeurs recherchées.
Le code devient alors:

//Set pin numbers:
const byte joyStickPinA = A1;
const byte motorSpeedPinA = 5;
const byte motorDirPin1A = 2;
const byte motorDirPin2A = 4;

const byte joyStickPinB = A2;
const byte motorSpeedPinB = 6;
const byte motorDirPin1B = 7;
const byte motorDirPin2B = 8;

//variables
//Joystick input variables
int joyValueA = 0;
int joyValueB = 0;
int joyValueMax = 1023;
int joyValueMin = 0;
int joyValueMid = 512;
int joyValueMidUpper = joyValueMid + 8;
int joyValueMidLower = joyValueMid - 8;
 
//DC motor variables
byte motorSpeedA = 0;
byte motorSpeedB = 0;
byte motorSpeedMax = 255;
byte motorSpeedMin = 1;

unsigned long startDelayA;
unsigned long startDelayB;

int tempo = 8;

void setup()
{
    pinMode(joyStickPinA, INPUT);
    pinMode(motorSpeedPinA, OUTPUT);
    pinMode(motorDirPin1A, OUTPUT);
    pinMode(motorDirPin2A, OUTPUT);

    pinMode(joyStickPinB, INPUT);
    pinMode(motorSpeedPinB, OUTPUT);
    pinMode(motorDirPin1B, OUTPUT);
    pinMode(motorDirPin2B, OUTPUT);

    startDelayA = millis();
    startDelayB = millis();
    
    
}
 
void loop()
{
    joyValueA = analogRead(joyStickPinA);
         
    if(joyValueA > joyValueMidUpper) //Forward
    {
        motorSpeedA = map(joyValueA, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardA(motorSpeedA);
    }
    else if(joyValueA < joyValueMidLower) //Backward
    {
        motorSpeedA = map(joyValueA, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardA(motorSpeedA);
    }
    else
    {
       MotorStopA();
    }
    
    joyValueB = analogRead(joyStickPinB);
    
    if(joyValueB > joyValueMidUpper) //Forward
    {
        motorSpeedB = map(joyValueB, joyValueMidUpper, joyValueMax, motorSpeedMin, motorSpeedMax);
        MotorForwardB(motorSpeedB);
    }
    else if(joyValueB < joyValueMidLower) //Backward
    {
        motorSpeedB = map(joyValueB, joyValueMidLower, joyValueMin, motorSpeedMin, motorSpeedMax);
        MotorBackwardB(motorSpeedB);
    }
    else
    {
       MotorStopB();
    }
 
}

void MotorForwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 1);
    digitalWrite (motorDirPin2A, 0);    
    if (millis() >= startDelayA + (2400/SpdA)-10)
    {  digitalWrite (motorSpeedPinA, 1);
       if (millis() >= tempo + startDelayA + (2400/SpdA)-10)
              {digitalWrite (motorSpeedPinA, 0);
               startDelayA = millis(); // on mémorise le temps courant du chrono    
               }
    }
}

void MotorBackwardA( byte SpdA)
{
    digitalWrite (motorDirPin1A, 0);
    digitalWrite (motorDirPin2A, 1);    
    if (millis() >= startDelayA + (2400/SpdA)-10)
    {  digitalWrite (motorSpeedPinA, 1);
       if (millis() >= tempo + startDelayA + (2400/SpdA)-10)
              {digitalWrite (motorSpeedPinA, 0);
               startDelayA = millis(); // on mémorise le temps courant du chrono    
               }
    }
}

void MotorStopA()
{
    analogWrite(motorSpeedPinA, 0); 
}

void MotorForwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 1);
    digitalWrite (motorDirPin2B, 0);    
    if (millis() >= startDelayB + (2400/SpdB)-10)
    {  digitalWrite (motorSpeedPinB, 1);
       if (millis() >= tempo + startDelayB + (2400/SpdB)-10)
              {digitalWrite (motorSpeedPinB, 0);
               startDelayB = millis(); // on mémorise le temps courant du chrono    
               }
    }
} 
void MotorBackwardB( byte SpdB)
{
    digitalWrite (motorDirPin1B, 0);
    digitalWrite (motorDirPin2B, 1);    
    if (millis() >= startDelayB + (2400/SpdB)-10)
    {  digitalWrite (motorSpeedPinB, 1);
       if (millis() >= tempo + startDelayB + (2400/SpdB)-10)
              {digitalWrite (motorSpeedPinB, 0);
               startDelayB = millis(); // on mémorise le temps courant du chrono    
               }
    }
} 
void MotorStopB()
{
    analogWrite(motorSpeedPinB, 0);  
}

On obtient ainsi de fréquences allant de 1 Hz à 125 Hz pour des impulsions de 8 ms.
Si on utilise des impulsions de durée différente, il faudra ajuster le coefficient additionné par le soft lors des tests de durée d'intervalle, de manière à arriver à un signal de rapport cyclique aussi proche que possible de 100% lorsque le joystick est actionné à fond.

[davidkings]

Tout d'abord merci pour le temps que tu prends pour m'aider.
Je ne sais pas de quel coin tu es, mais si tu passes par Aix-en-Provence, dis-le moi, je te payerai un verre !

Je vais t'expliquer comment j'ai procédé pour obtenir 150, qui est la vitesse à laquelle démarre le moteur.

- J'ai mis d'abord le chiffre 1. Je pousse le joystick, le moteur fait un boucan de bruit mais ne tourne pas, je continus de pousser le joystick jusqu'à ce que le moteur fini par tourner. Je change les valeurs du delay afin que le moteur démarre au plus tôt sans trop de saccades.
150 est donc la valeur à laquelle le moteur commence à tourner. Si je laisse 1, il ne va pas tourner moins vite, on va juste entendre des grognements, des saccades, des à coups sur toute la course du joystick allant de 0 à 149.
Je n'ai rien obtenu de bon en 12v, ça tourne trop vite d'un coup, vers 150. J'ai donc baissé la tension d'alim à 6v. A 6v, le moteur démarre à 220 mais au moins, il tourne beaucoup moins vite que la vitesse mini en 12v, (même si on est loin de la vitesse mini idéale) par contre, on a une amplitude de vitesse très réduite (de 220 à 255).

Me suis-je fait comprendre ?

Actuellement, j'ai deux versions de programmation exploitables, dont le résultat est identique (même vitesse mini) : moteurs alimentés en 6v pour obtenir la vitesse la plus basse possible.

- la version d'origine, avec les analogwrite et le moteur qui démarre à 210
- la version avec les millis () et delay, qui ne fait pas tourner le moteur moins vite, mais qui lui fait faire moins de bruit. Le moteur démarre aussi à 210.

[davidkings]

je viens de lire ton post #71. Je vais essayer.

Avec la fonction millis(), je n'ai pas observé de chute de vitesse notable lorsque les deux moteurs sont alimentés, contrairement à ton programme avec les delay et la periodeRefr.

Par contre, même avec un seul moteur, on arrive à faire le tourner très lentement mais avec un delay très long (15ms), du coup, ça fait des saccades ignobles qui font vibrer toute la structure de ma tête motorisée et la caméra (je ne sais pas si c'est bon pour le moteur). En dessous de 15ms, ça ne tourne pas (en position lente du joystick) mais on entend des claquements à une fréquence très rapide qui font aussi vibrer toute la structure de ma tête motorisée .

[davidkings]

Je ne comprends pas la ligne

if (millis() >= startDelayA + (2400/SpdA)-10)

Comment arrives-tu à 2400 et -10 ?

pour une vitesse de 1, on obtient

if (millis() >= startDelayB + (2400/SpdA)-10)
if (millis() >= startDelayB + (2400/1)-10)
if (millis() >= startDelayB + 2390

soit une temporisation de plus de 2 secondes entre chaque impulsion ?

puis on envoie une impulsion de plus de 2 secondes ?

if (millis() >= tempo + startDelayA + (2400/SpdA)-10)
if (millis() >= 8+ startDelayA + (2400/1)-10)
if (millis() >= startDelayA + 2398)

Donc le moteur tourne pendant 2sec puis s'arrête pendant 2sec etc

[Yvan_Delaserge]

A la vitesse minimum, on a une impulsion de 8 ms toutes les 2 secondes, donc une fréquence de 0,5 Hz. Si c'est trop peu, il faut modifier les fonctions map.

[Yvan_Delaserge]

Enfin je veux dire modifier pas la fonction map elle-même, mais augmenter la variable MotorSpeedmin.

[davidkings]

J'ai essayé. Tes deux idées sont bonnes et fonctionnent sur le principe, mais la rotation n'est pas du tout fluide en basse vitesse et l'utilisation n'est pas possible. La rotation devient fluide et exploitable quand on atteint les 3/4 de la course du joystick.

Je pensais à une chose : n'existe t-il pas un composant qui transforme le signal pwm en signal analogique, en amont des moteurs ?

Mes moteurs tournent très lentement et avec fluidité et silence sous 3v analogique (sur secteur). Au lieu d'envoyer le signal PWM directement au moteur, on envoie à un composant qui transforme ce signal en tension analogique et l'envoie au moteur.

[Yvan_Delaserge]

Si, bien sûr, il faut construire un intégrateur, un filtre passe-bas. Le circuit est le suivant:



Pour la résistance, il faut prendre une valeur du même ordre que celle du moteur.
Pour le condensateur on peut prendre 1000 uF bipolaire.

Il faut connecter les deux fils de gauche à la sortie du shield et ceux de droite au moteur.

[davidkings]

Rien qu'avec une résistance et un condensateur ?

Et lorsque le moteur tourne dans le sens inverse, avec le + et - inversés, cela ne va t-il pas poser de pb ?

[Yvan_Delaserge]

pas si tu utilises un condensateur bipolaire.

A part ça, si tu cherches à obtenir des déplacements précis à faible vitesse pour une monture de caméra, as-tu pensé à utiliser des moteurs pas à pas?

[davidkings]

En toute sincérité, penses-tu que le rajout d'un intégrateur pourra corriger mon problème ?

Je n'ai jamais vu de têtes motorisées avec moteur pas à pas. Il y a sûrement une raison.
Ma vitesse mini doit être de l'ordre de 0.3 à 0.5 tr/min et la maxi de 3tr/min.

[Yvan_Delaserge]

En toute sincérité, penses-tu que le rajout d'un intégrateur pourra corriger mon problème ?

Ben en toute sincérité, je pensais qu'un signal PFM pourrait corriger le problème, et la dernière version du soft fournit un signal PFM irréprochable. Et pourtant, ça ne marche pas avec ton montage.

Ce que je peux te dire, c'est que le filtre passe-bas va te transformer un signal PWM en un signal proche d'un courant continu dont la tension va dépendre du rapport cyclique du signal PWM. Alors si c'est ça dont ton moteur a besoin, oui, c'est un essai à faire. Mais là aussi, la théorie est une chose et la pratique, une autre.

Je n'ai jamais vu de têtes motorisées avec moteur pas à pas. Il y a sûrement une raison.
Ma vitesse mini doit être de l'ordre de 0.3 à 0.5 tr/min et la maxi de 3tr/min.

Les petits moteurs pas à pas dont je t'ai envoyé la référence sont démultipliés environ 1:60 et on peut leur envoyer un signal allant jusqu'à 100 Hz. Ils vont tourner de 100 pas / seconde. Il y a une soixantaine de pas par tour ( je te dis ça de mémoire). Donc pour que l'axe extérieur tourne de 1 tour, il faudra 60 x 60 pas = 3600 pas. Il faudra donc 36 secondes pour un tour. Donc environ 2 tours/minute. C'est idéal pour ton application. Et surtout, tu peux obtenir des rotations extrêmement lentes.

Regarde par exemple ici:

L'avantage de ces moteurs pas-à-pas, c'est qu'ils sont très bon marché. Si tu veux un moteur à courant continu qui démarre à basse tension-basse vitesse, il faut un moteur de très bonne qualité, type Maxon par exemple. Et ce n'est pas donné.

[Yvan_Delaserge]

Ou alors, il faut essayer avec d'autres moteurs que ceux que tu as.

C'est vrai que le texte dont on a tiré l'idée du PFM parlait plutôt d'une application en robotique, par exemple pour faire avancer un micro-robot, donc les vibrations et le bruit n'étaient pas un problème. Maintenant, si tu nous dis que c'est pour faire tourner une caméra, c'est autre chose.

Les petits moteurs que je t'ai signalé sont silencieux et tournent sans saccades ni vibrations.

[davidkings]

Bonjour,

Quelques nouvelles. J'ai terminé ma tête motorisée il y a quelques temps. Depuis, je me suis consacré à la télécommande.
Au début, ça fonctionnait pas mal mais un moteur refuse de démarrer à basse vitesse, sûrement des frottements dans la série d'engrenages qui baignent dans un magma de graisse qui doit elle-même freiner la rotation.
Malheureusement, mon utilisation très occasionnelle de cette tête ne me permet pas de débourser une fortune dans un moteur Maxon.

Voici un petit reportage de mon système terminé :