shield motor rev 3 HS

Bonjour tout le monde ! je suis actuellement sur un projet pour piloter un moteur 18v NIDEC reference 404.148 avec un shield motor REV 3 ; j'ai retiré le pin VIN pour pouvoir alimenter mon shield motor en 24V (déjà est ce que je n'ai pas fais une bétise a ce niveau la ?).
mon alimentation pour le shield est la suivante : 2 batteries en série de 12V 7.0Ah.
le projet est le suivant : piloter le moteur dans les 2 sens de rotation a l'aide de 2 bp.
une fois le programme créée , j'ai appuyé sur le premier bouton poussoir : le moteur s'est mit a tourner, quand j'ai appuyé sur le second c'est la que j'ai grillé le pont en H.
pensez vous que le problème vienne de mon programme? ou est ce ma protection moteur qui est trop juste?

int boutonhaut ;//rotation du moteur dans un sens
int boutonbas ;//rotation du moteur dans le sens opposé
const int vitesseMotA= 3; // Constante pour la broche 3
const int sensMotA= 12; // Constante pour la broche 12
const int freinMotA= 9; // Constante pour la broche 9
boolean etatboutonhaut;
boolean etatboutonbas;

void setup() {
  // put your setup code here, to run once:
  boutonhaut = 2;
  boutonbas = 4;
  pinMode (2, INPUT_PULLUP);//pour activer la résistance interne a l'arduino
  pinMode (4, INPUT_PULLUP); // si pas de résistance le pin quand le bp est levé n'est connecté arien, résultat lu donc peu interprétable
  pinMode (12,OUTPUT); // initialisation moteur 
  pinMode (9,OUTPUT); // initialisation frein
  pinMode (3,OUTPUT); // vitesse rotation
  Serial.begin(9600);// ouverture port de communication

}

void loop() {
  Serial.println(etatboutonhaut);
  Serial.println(etatboutonbas);
  if (digitalRead(2)==LOW)
  {
  digitalWrite (9,LOW);   //frein désactivité 
  digitalWrite (12,HIGH);// moteur tourne dans un sens
  digitalWrite (3,255);  // vitesse maxi
  Serial.println ("Le moteur tourne a l'endroit");
  }
  
if (digitalRead(4)==LOW)
{ 
  digitalWrite (9,LOW);  //frein désactivité
  digitalWrite (12,LOW); //moteur tourne sens inverse
  digitalWrite (3,255); //vitesse maxi
  Serial.println ("Le moteur tourne a l'envers");
  
}
delay(200);
  // put your main code here, to run repeatedly:

}

en vous remerciant par avance :smiley:

On va résumer :

digitalWrite (3,255); // on utilise plutôt analogWrite() pour le PWM

Le changement de sens de rotation a certainement entraîné un freinage brutal et un courant important. Je veux dire par là que comme le moteur tournait à fond dans un sens, il a eu besoin d'un courant très important pour changer de sens.

Dans la datasheet je vois : nominal current 6A (plutôt inquiétant pour un L298 limité à 2A).

merci hbachetti,
je remplace analogwrite pour le PWM
comment faire en sorte que le changement de sens de rotation n'entraine pas un freinage brutal?
j'ai également modifier une partie du programme :
if ((digitalRead(2)==LOW)&(digitalRead(4)==HIGH))
et
if ((digitalRead(4)==LOW)&(digitalRead(2)==HIGH))

pour ne pas actionner simultanément les 2 commandes.

existe il des shields plus adapter?

j'ai également supprimer les lignes
digitalWrite (3,255); //vitesse maxi

c'est cette ligne qui faisait démarrer mon moteur a fond directement?
comment faire en sorte qu'il accélère progressivement?

existe il des shields plus adapter?

Certainement. Peut être pas sous forme de shield, il faut chercher.

Ce qui manque : que comptes-tu faire avec ce moteur ?
Si c'est pour jouer, essaie d'utiliser un moteur plus petit.

https://images.app.goo.gl/heC97FZrVYURCPHt8

A mon travail nous avons des chariots porte bobine tms 80, la carte électronique de gestion du moteur est hs (600euros)et je pensais pouvoir la remplacer par une carte arduino et un shield.

joebillybob:
https://images.app.goo.gl/heC97FZrVYURCPHt8

A mon travail nous avons des chariots porte bobine tms 80, la carte électronique de gestion du moteur est hs (600euros)et je pensais pouvoir la remplacer par une carte arduino et un shield.

Bonjour
pragmatiquement , c'est typiquement le genre de cas (faible récurrence d'inversion) où je "collerais" un pont en H hybride
basiquement :
un relais 2 RT pour l'inversion , un mosfet pour le PWM

si je rajoute des relais 2 RT et un mofset pour le PWM, il manque quand meme les diodes de roue libre pour dissiper le courant induite non?(diode qui sont présentes dans mon shield motor rev3)
j'ai un doute par rapport a mon programme
"digitalWrite (3,255); //vitesse maxi"
cette ligne est elle nécessaire?
le fait que le moteur soit alimenter au maximum des le début ne pose pas de problème?

peut on avec une carte arduino, jouer le role de démarreur progressif ou jouer le role d'un variateur , pour créer une courbe d'acceleration?

"digitalWrite (3,255); //vitesse maxi"
cette ligne est elle nécessaire?
le fait que le moteur soit alimenter au maximum des le début ne pose pas de problème?

J'ai déjà répondu à cette question :

digitalWrite (3,255); // on utilise plutôt analogWrite() pour le PWM

Donc pas digitaWrite(), plutôt analogWrite().
Avec digitaWrite() tu balance la sauce à fond, tu n'as aucune chance de démarrer progressivement.

ha oui exact désolé , mais ca ne m'explique pas comment démarrer progressivement?

edit : ou alors le fait d'écrire analogWrite() permet d'établir une plage d'acceleration progressive 0>255?

byte vitesse =0;
byte pas=1; //   pas de progressivité 
int progression =200;   //delais entre entre 2 augmentation en milli secondes 

For (vitesse=0, vitesse <=255,vitesse=vitesse+pas)
{ 
   analogWrite (3,vitesse);  // on utilise plutôt analogWrite() pour le PWM
    Delay(progression );  //  attention, fonction blocante
}

Dans ce exemple tu augmente la vitesse de 1/255eme toutes les 200 ms..
Tu peux jouer sur tous les paramètres
Et repartir de la vitesse maxi vers le minimum.
Par contre avec une vitesse de 1 ton moteur risque de ne pouvoir démarrer faut tester

byte vitesse =0;
byte pas=1; //   pas de progressivité
int progression =200;   //delais entre entre 2 augmentation en milli secondes

j'écris cette partie dans mon void setup?

For (vitesse=0, vitesse <=255,vitesse=vitesse+pas)
{
   analogWrite (3,vitesse);  // on utilise plutôt analogWrite() pour le PWM
    Delay(progression );  //  attention, fonction blocante
}

donc si j'ai bien compris , par exemple j'écris analogWrite (3,200) et mon moteur atteindra la valeur 200 en 40 000 milli secondes ( 200x200 si je garde le pas de progressivité à 1)

je ne comprend pas cette partie :
For (vitesse=0, vitesse <=255,vitesse=vitesse+pas)

dans mon cas précis, comment je dois écrire mon activation de monté ou descente moteur dans mon programme ?

analogWrite (3,vitesse);

Si vitesse vaut ZERO -> PWM = 0% donc vitesse nulle.
Si vitesse vaut 255 -> PWM = 100% donc vitesse maxi.

Si vitesse vaut ZERO -> PWM = 0% donc vitesse nulle.
Si vitesse vaut 255 -> PWM = 100% donc vitesse maxi.

j'ai bien compris que la valeur PWM est comprise entre 0(0% mini) et 255(100%,max) ,
mais ton message ne m'aide pas vraiment dans la compréhension d'une phase d'acceleration de mon moteur et dans l'écriture étape par étape du pilotage de mon moteur avec une phase d'accélération.

ou alors si je marque:
analogWrite (3,255);
mon moteur sera alimenté avec PWM maximum mais cette valeur sera atteinte par mon pas de progressivité et mon délais?

Arzou t'a donné la solution en #11 avec une boucle for().

Attention : for s'écrit en minuscules.

byte vitesse =0;
byte pas=1; //   pas de progressivité 
int progression =200;   //delais entre entre 2 augmentation en milli seconde

Tu le met avant le setup,

for (vitesse=0, vitesse <=255,vitesse=vitesse+pas)

Je te traduit en francais:
Pour une valeur de la variable "vitesse" qui commence à 0 ajoute a la valeur de la variable "vitesse" le contenue de la variable "pas" et celà tant que le contenu de la variable "vitesse" soit inférieure ou égale à 255

Si cette limite est atteinte, on sort de la boucle ci après :

{ 
   analogWrite (3,vitesse);  // on utilise plutôt analogWrite() pour le PWM
    Delay(progression );  //  attention, fonction blocante
}

Ici, a chaque tours de boucle, 1) tu envoie a la broche 3 le contenu de la variable "vitesse"
2) tu fait une pause DANS LA BOUCLE de la durée du contenu dela variable "progression "
Durant la pause, ton moteur continue a tourner a la même vitesse

Va jeter un oeil ici pour bien démarrer avec arduino

merci !
du coup dans mon cas de figure mon programme ressemble à ça , c'est ça ?

if (digitalRead(2)==LOW)
  {
  digitalWrite (9,LOW);   //frein désactivité
  digitalWrite (12,HIGH);// moteur tourne dans un sens
  for (vitesse=0, vitesse <=255,vitesse=vitesse+pas)
{
   analogWrite (3,vitesse);  // on utilise plutôt analogWrite() pour le PWM
    Delay(progression );  //  attention, fonction blocante
}
  Serial.println ("Le moteur tourne a l'endroit");
  }

joebillybob:
merci !
du coup dans mon cas de figure mon programme ressemble à ça , c'est ça ?

if (digitalRead(2)==LOW)

{
  digitalWrite (9,LOW);  //frein désactivité
  digitalWrite (12,HIGH);// moteur tourne dans un sens
  for (vitesse=0, vitesse <=255,vitesse=vitesse+pas)
{
  analogWrite (3,vitesse);  // on utilise plutôt analogWrite() pour le PWM
    Delay(progression );  //  attention, fonction blocante
}
  Serial.println ("Le moteur tourne a l'endroit");
  }

oui, faut voir le reste du code et surtout le câblage.
de plus , lorsque tu veux inverser le sens de fonctionnement de ton moteur, laisse une tempo suffisante pour laisser le moteur s’arrêter ou alors prévoir un pont en H qui sera capable d'encaisser la surcharge en intensité... et en étant certain que mécaniquement ton moteur est capable de le supporter lui aussi...

parfait j'ai juste du remplacé les , par des ; dans mes parenthèses de ma condition for.

j'ai également rajouté un delay de 1500 avant le démarrage du moteur .

pourrais tu me conseiller un pont en H pour mon moteur 18v NIDEC reference 404.148 (6A en nominal et d'après la doc 20 A max)?