Câblage conforme pour deux steppers et une every ? le doute subsiste

Bonjour à tous !

J'ai entrepris la construction d'un petit automate animé par deux moteurs pas à pas.

étant maxi débutant, j'ai eu l'immense fierté de voir que l'ensemble a bien fonctionné !
..... pendant un temps !

  • Soudainement l'un des moteurs à cesser de tourner. il se contente d'un "buzz".
    moteur que j'ai testé indépendamment ensuite - avec succès, il réagit bien,
  • ce qui n'est pas le cas de son driver qui semble endommagé.

Voyez-vous une erreur dans le montage - ou dans le code - qui aurait pu causer sa perte ?

je me permet de vous solliciter, dans le rêve fou et la quête perpétuelle de vouloir apprendre de ses erreurs (et surtout d'éviter de les reproduire indéfiniment jusqu'au bout de sa vie).... :grinning:

voici le matériel mobilisé

cablage_V2.pdf (431.1 KB)

////////////////////////////////////////
////////////////////////////////////////

// Include the AccelStepper library:
#include <AccelStepper.h>

int SENSOR = 7;                            // affectation du sensor Hall magnetic
#define PHOTO 5                            // affectation LED - déclenchement photo
#define buzzer 6                           // affectation du buzzer
int frequence[] = { 262, 330, 370, 440 };  // des notes


// MOTEUR - PAN
AccelStepper tourne(AccelStepper::DRIVER, 11, 10);  // PUL , DIR

// MOTEUR - TILT
AccelStepper monte(AccelStepper::DRIVER, 9, 8);  // PUL , DIR


void homing() {
  monte.setMaxSpeed(1300);
  monte.setAcceleration(3000);
  // Set the target position:
  monte.move(-3000);
  monte.run();
}

////////////////

void positioning() {
  monte.setMaxSpeed(300);
  monte.setAcceleration(1000);
  // Set the target position:
  monte.move(1000);
  monte.run();
}

////////////////

void bipbip() {


  digitalWrite(buzzer, HIGH);
  delay(200);
  digitalWrite(buzzer, LOW);
  delay(100);
  digitalWrite(buzzer, HIGH);
  delay(150);
  digitalWrite(buzzer, LOW);
  delay(100);
  digitalWrite(buzzer, HIGH);
  delay(100);
  digitalWrite(buzzer, LOW);
  delay(100);
}

////////////////

void clic() {
  delay(200);  // Pause
  digitalWrite(PHOTO, HIGH);
  delay(50);  // Pause
  digitalWrite(PHOTO, LOW);
  delay(1000);  // Pause
}


////////////////


void clicetclac()


{
  monte.setCurrentPosition(0);

  for (int i = 0; i < 5; i++) {

    tourne.setCurrentPosition(0);

    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(2500);
    monte.runToPosition();

    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(5200);
    monte.runToPosition();

    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(8000);
    monte.runToPosition();

    clic();

    delay(100);  // Pause
    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(11200);
    monte.runToPosition();

    clic();

    ////////////tourne !////////////////

    delay(100);  // Pause
    tourne.setCurrentPosition(0);
    tourne.setMaxSpeed(5000);
    tourne.setAcceleration(2000);
    tourne.move(4080);
    tourne.runToPosition();
    delay(500);  // Pause

    ////////////////////////////

    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(8000);
    monte.runToPosition();

    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(5200);
    monte.runToPosition();


    clic();

    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(2500);
    monte.runToPosition();

    clic();


    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    monte.moveTo(0);
    monte.runToPosition();

    clic();


    ////////////tourne////////////////

    delay(100);  // Pause
    tourne.setCurrentPosition(0);
    tourne.setMaxSpeed(5000);
    tourne.setAcceleration(2000);
    tourne.move(4080);
    tourne.runToPosition();
    delay(100);  // Pause
  }
}

////////////////

void tiltretour() {
  {
    monte.setMaxSpeed(5000);
    monte.setAcceleration(2000);
    // Set the target position:
    monte.moveTo(2500);
    // Run to target position with set speed and acceleration/deceleration:
    monte.runToPosition();
  }
}



////////////////



void setup() {
  pinMode(PHOTO, OUTPUT);
  bool capteurtilt = false;
  pinMode(SENSOR, INPUT);
  delay(200);   // Pause
  bipbip();     //master
  delay(1000);  // Pause


  do

  {
    if (!capteurtilt) {
      if (digitalRead(SENSOR) == HIGH)
        // avancer un peu
        homing();
      else
        // signaler position atteinte
        capteurtilt = true;
    }
  }

  while (!capteurtilt);

  delay(300);             // Pause
  clicetclac();             // master
  delay(500);             // Pause
  bipbip();               //master
  delay(100);             // Pause
  tiltretour();           //master
  delay(500);             // Pause
}

void loop() {

  digitalWrite(buzzer, HIGH);
  delay(100);
  digitalWrite(buzzer, LOW);
  delay(100);
  {
    for (int i = 0; i < 1; i++) {
      tone(buzzer, frequence[i], 100);
      delay(500);
    }
  }
  delay(100);
  digitalWrite(buzzer, HIGH);
  delay(100);
  digitalWrite(buzzer, LOW);
  delay(200);
  digitalWrite(buzzer, HIGH);
  delay(100);
  digitalWrite(buzzer, LOW);
  delay(900);
}

Je n'y connais rien, j'ai juste buté sur le 1.8A/phase.
Sa sous entends que c'est 2 x 1.8A => 3.6A max (moteur bipolaire) ?
Si oui le driver pouvant encaisser 3.2A serait sous dimensionné ?

il s'agit effectivement de moteurs bipolaires (1.68Amps/phase)

  • Mais chaque moteur ayant son propre driver respectif à lui même.
    j'ai l'impression qu'on reste dans les clous

(et accessoirement, les deux fripouilles ne tournent jamais en même temps)

edit : pour détailler : les "DIP switchs" des drivers sont réglés en
"Peak Current : 1.94A | RMS Current : 1.39A"

Non, c'est le driver qui fait la limitation du courant. Si il est sur 1,39A, il ne donnera pas plus. En plus ils sont protégés contre les échauffements excessifs.
Je tourne avec des 1,6A mais avec un driver qui ne peut pas aller jusque-là. Il y a moins de couple possible, c'est tout.

Normalement le driver est protégé contre les courts-circuits. Il ne devrait pas griller.

Bonjour à tous,

je crois avoir trouvé une piste.

  • Le problème se situerai plutôt côté LED (SMD - blanche - 3,2-3,4v - 1w - 350mA )
    et qui visiblement, demande bien trop de puissance pour l'arduino)

Dans mon programme elle agit comme un "flash"... ce qui a peut-être "grillé" la nano... mais "petit à petit"...

  • Selon vous, quel pourrait-être le montage correct (et compact) ?

Qui m'éviterai l'utilisation :

merci de vos lumières !

Une led "3,2-3,4v - 1w - 350mA" ne doit pas être commandée en tension par exemple au travers d'un module abaisseur. La led peut faire 3,4V à froid et si on l'alimente en 3,4V, elle peut chauffer ce qui va baisser sa tenson, le courant va croitre et elle risque de griller. Les leds doivent s'alimenter en courant. Comme ce n'est pas simple, on y met une tension plus élevée (par exemple 5V) et on met en série une résistance.
Dans le cas présent 3,2V;350mA pour la led, cela fait (5V-3,2V);350mA pour la résistance; Il faut donc une résistance de (5V-3,2V)/0,35A=5,1Ω et (5V-3,2V)*0,35A = 0,6W. Il faut donc choisir 5,1Ω-1W

Pour alimenter une diode 350mA, on met en général un transistor, voir par exemple la page d'Henri, il y a un schéma pour un relais, il faut remplacer le relais et sa diode par la Led et la résistance série. N'hésite pas à faire valider le choix du transistor et du montage.

On peut aussi utiliser une relais pour alimenter en 5V la diode et sa résistance série. Mais un relais est plus bruyant et moins fiable.

Super !
Merci d'avoir pris le temps de cette réponse.
J'ai plein d'infos pour avancer du coup !

(comme je régule déjà l'accu (pour alimenter l'arduino)
je vais partir du 9v produit pour alimenter la led !

donc, si je me base sur ton calcul :
(9v-3,2v)/0,35A=16,5Ω
(soit un montage en série 15Ω + 1,5Ω)

pour l'utilisation du transistor... je découvre un "gros morceau", avec beaucoup de données à ingérer.. pas certain d'y voir clair pour le moment...
mais j'ai des relais, je vais m'en servir dans l'immédiat.

merci encore !
je vais essayer cette piste.

C'est pas faux.... Mais.

Quand on alimente une led 3V environ avec une tension supérieure on a une perte. Si on n'en voulait pas, il faudrait alimenter en courant ce qui et rare.

Pour une led de 3,2V alimentée en 5V, il va y avoir 1,8V aux bornes de la résistance. Cette dernière va faire des pertes d'énergie d'environ la moitié de l'énergie nécessaire pour la led.
la led a besoin de 3,2Vx0,35A soit 1,12W
la résistance va "perdre" 1,8Vx0,35A soit 0,63W

Si on utilise une tension de 9V, on va maintenant avoir:
la led a toujours besoin de 3,2Vx0,35A soit 1,12W
la résistance va "perdre" (9V-3,2V)x0,35A soit 2W
C'est possible, mais il faut prendre une résistance de 2W minimum. Si on est sur le secteur avant 2022, cela ne pose pas de problèmes (on s'en foutait). A partie de 2022, cela fait rechigner un peu. Mais sur batterie c'est plus un problème car on tire 1,4W en plus.

Les solutions:
− on est conscient que cela va tirer plus sur la batterie, ce qui va diminuer la durée d'utilisation.
− on utilise un convertisseur 9V -> 4V. plus compliqué mais on y gagne en autonomie.
− on met deux leds comme celle que tu as, en série, mais en divisant le courant par 2 (175mA). Au total on récupère la même intensité lumineuse, mais on tire moins sur la batterie (en fait comme le rendement d'une led diminue si le courant augmente, on aura un peu plus de lumière). les deux leds auront ensemble une tension de 6,4V et il y aura 2,6V environ pour la résistance. Mais comme le courant est de 0,175mA, la résistance ne dissipe que 0,5W
− on utilise un circuit qui délivre le courant voulu. Si il fonctionne par découpage, on a très peu de pertes. Cela est idéal pour la durée de vie de la batterie. Je ne sais pas si cela existe, je serais presque tenté d'utiliser un circuit pour pas à pas, mais il faudrait d'autres avis.

Merci pour ces précisions !
"remouliner" le 9V, c'est très faisable.

pour "le circuit qui délivre un courant voulu"
Je vois qu'il existe des composants "dédiés" !

d'ailleurs, peut-être que l'achat d'un de ces "drivers" serait finalement plus simple pour moi.
car d'après ce que je décode des specs du LDD-350L (datasheet) :sweat_smile: - >Je pourrais activer ma led directement depuis la nano, en alimentant en 5v le "DIM" du driver, qui lui serait alimenté en 18v depuis l'accu "principal". Ce driver combinerai donc le relais, le convertisseur, les résistances.

C'est aussi ce que je comprends.
C'est surtout une consommation moindre sur l'accu.

Je vois la possibilité du tout ou rien ou d'utiliser la variation de lumière.