Controler moteur CC 6A

Bonjour à tous

Je fais appel à vous afin d’avancer dans mon projet où je pèche un peu sur la partie électronique.

Je suis en train de fabriquer un caisson levant, tout est prêt, le caisson, les rails, guides, crémaillère, pignon etc… il me reste la partie moteur, après quelques test avec un moteur d’essuie glace ( motoréducteur en courant continue de 12V et couple 3.5Nm), je me rend compte que c’est un peu juste, je prévois donc de le remplacer par un plus puissant :

Un motoréducteur DOGA 319.3862.2B.00 avec pour caractéristique :

tension nominale : 12V

Courant nominal : 6A

Courant de démarrage : 50A

Couple nominal : 8Nm

En PJ les courbes du moteur.

Sachant que je surdimensionne un peu le moteur par précaution.

Après quelque recherches, j’ai vu qu’il était assez compliqué de contrôler le sens et la vitesse d’un moteur CC sur une base de relais et d’interrupteur, je me dit qu’en passant par un montage à base d’Arduino sera plus simple.

C’est l’occasion d’apprendre à utiliser et programmer l’arduino :slight_smile:

Je n’ai pas assez de compétence pour créer un circuit de contrôle, je pense passer par un shield moteur, que pouvez vous me conseiller pour mon moteur ? Les circuit à base de L293 / L298 ne sont pas assez puissant pour mon utilisation.

Pour le principe de fonctionnement j’aimerai que quand j’appuie sur un bouton( ou interrupteur), le moteur tourne dans un sens (pour faire lever le caisson jusqu’à un autre microrupteur de fin de course), quand je reappuie sur le bouton, le moteur tourne dans l’autre sens pour faire descendre le caisson qui s’arrete à un 3ieme microrupteur.

Que pouvez vous me donner comme conseils pour réaliser ce projet au niveau électronique / sur le type de code à utiliser ?

Merci d’avance pour votre aide :smiley:

courbe moteur.jpg

C'est sympa d'avoir une question et toute la documentation pour y répondre.... c'est rare.

Moteur CC à double sens avec arrêt possible, aujourd'hui on privilégie un pont en H à MOSFET. Pour commander les grilles, il faut une interface car l'arduino fournit une tension trop basse. Pour ne pas s'embêter, et pour garder la sécurité des ponts tout faits , je préconise un pont classique genre L298 avec derrière un ampli à MOSFET:

Ainsi, l'électronique est plus simple et il n'est pas possible de faire passer le courant dans tous les transistors en même temps, ce qui peut détruire l'alim ou les transistors. Je pense en particulier à des erreurs de programmation.

Ce que j'avais écrit sur le sujet

Je pense que même un L293 suffirait. Plus petit, plus facile à implanter. J'ajouterais tout de même deux résistance grille-source sur deux des transistors (haut ou bas) afin de fixer les potentiels au démarrage ou quand la broche EN est LOW.

bonjour,
tout fait il existe un “monster driver” qui peux piloter 2 moteurs 30A


on peux utiliser les 2 cannaux en // pour 60A

Merci pour vos réponse :slight_smile:

J’avoue que ce n’ai pas toujours évident d’avoir toutes les données, surtout sur des composants d’occasion, là ça va c’est du neuf et le fournisseur fournis tout ce qu’il faut :slight_smile:

Oliver, tu me conseille de prendre un shield à base de L298, et de faire un pont en H à mofset à sa sortie ( borne alimentation moteur) si j’ai bien compris ? Le pont à mofset va me permettre de controler un moteur plus puissant que ce que peut supporter le L298?

J’ai trouvé un shield moteur pas mal ( megamoto 1x13A chez gotronic), mais 50€ le shield ça fait cher. Le monster driver m’a l’air moins cher, a voir si ça vaut le coup de commander un shield tout fait. Bon en ce moment c’est un peu compliqué de commander à l’étranger XD.

Quand je branche mon moteur en direct, le caisson met 12 seconde pour se lever, et 5 sec pour descendre, et je sens qu’il peine un peu pour le lever sachant que pour l’instant c’est à vide :stuck_out_tongue: donc vaut mieux viser plus gros.

J’ai réfléchi un peu au fonctionnement pour pouvoir écrire mon programme plus tard, j’ai fait un logigramme, qu’en pensez vous ?

Maintenant je me pose des question sur le montage: Au moment de la commutation, si on est à 12V d'alimentation, un court instant si il y a 6V sur les grilles, les deux mosfets devraient être passants. Il faudrait que je ressorte tout mon matériel pour voir si il y a effectivement un courant à la commutation ou pas.

Pour le choix du montage final, c'est un peu selon chacun. Un shield tout prêt, cela facilite. Cela dépend aussi de ce que l'on a sous la main.

L'avantage du L298 est que l'on ne peut pas faire conduire les deux transistors d'une même branche en même temps, ce qui peut conduire à une catastrophe pendant la mise au point. Encore que parfois les alimentations acceptent le court-circuit. Si le programme fonctionne correctement du premier coup, je ne serais pas là à me chercher des poux sur la tête bugs dans le cerveau.

On peut se passer d'un pont tout fait, mais il faut passer de 5V à 12V, et cela économise le câblage. D'où l'intérêt du L298.

L'avantage du L293 c'est qu'il est plus petit, vu qu'il n'y a pas de puissance à passer pour commander les grilles. Pas d’inconvénients, pourquoi n'y ai-je pas pensé?

Si il y avait la bonne solution, il n'y aurait pas tant de possibilités sur le marché.

Effectivement, les deux résistances de protections (une pour fixer le potentiel au départ et une pur protéger l'arduino sont possible et n'y sont pas sur le schéma.

Avec un seul transistor, j'ai tendance à ne pas mettre de résistance entre la grille et la masse, parce que la capacité d'entrée des Mosfet est importante et elle suffit pour bloquer le mosfet pendant la mise sous tension. Avec les deux Mosfet, ce n'est plus le cas, la tension pourrait s'établir à 6V et ce serait la catastrophe.

Pour ce qui est des organigrammes, c'est vraiment pas mon truc. J'ai connu ça au lycée, mais je n'ai jamais apprécié. Ca a l'avantage de décrire un fonctionnement mais pour écrire le programme, pour moi cela complique. Je dirais aussi que c'est un problème typique pour une réalisation du style machine à états

Merci pour toutes ses explications, à part un fer à souder et de l'étain je n'ai pas grand chose XD

je vais plutot m'orienter vers un chield moteur tout fait si possible, j'ai trouvé un monster moto shield pour 11€ en allemagne, par contre pour l'arduino le prix ici me semble très bas : Lien ici

J'avoue que des logigramme j'en ai jamais fait et je n'aime pas ça non plus XD

monster moto shield pour 11€

C'est plus facile et c'est plus de tranquillité.

prix ici me semble très bas

C'est le prix normal pour une carte chinoise (il y a un CH340, le micro est petit et carré...). Je ne sais pas ce que cela vaut à la longue, j'ai choisi le chinois, et si j'ai un problème dans le temps, j'en changerais.

Mon projet avance petit à petit :slight_smile:

j’ai reçu la carte motoshield, le moteur, j’ai pu tester son efficacité via un programme test et pour avoir toute la puissance nécessaire au moteur j’utilise les 2 canaux en parallèle sinon il tourne moitié moins vite de ce qu’il devrait.

Donc j’ai commencé à le programme sur tinkercad afin de le teste au fur et à mesure sans tout griller XD.

actuellement j’ai réussi à faire une 1ere partie, mais comme je débute je bloque un peu pour la suite.

Voici ce que fait le programme : si le bouton 1 et 3 est appuyé alors tu allume la led test ( en bleu) et tu met en route le moteur sens horaire, sinon si le bouton 2 et 4 est appuyé tu allume le moteur sens anti-horaire, et sinon tu eteint tout.

J’ai simulé le motoshield via les led :

Bleu : led test
Rouge : activer moteur
Blanc : signal PWM ( une fois le montage fais, je remplacerai le DigitalRead par AnalogRead avec une valeur de 0/255 a la place de low/high pour avoir mon signal PWM)
Vert : moteur en sens horaire
jaune : moteur sens anti-horaire

Voici le code qui pour le moment fonctionne

//les broches A1/B1 et A2/B2 sont soudé ensemble pour avoir plus de puissance,
//ne pas oublier d'envoyer du courant en même temps dans les broches A1/B1 et A2/B2
//pour avoir toute la puissance moteur

// définition des broche de la carte en tant que variable
const int LED = 2;
const int Bouton1 = 10;
const int Bouton2 = 11;
const int Bouton3 = 12;
const int Bouton4 = 3;

const int MOTEUR_A1 = 7;
const int MOTEUR_B1 = 8;

const int MOTEUR_A2 = 4;
const int MOTEUR_B2 = 9;

const int PWM_MOTEUR_1 = 5;
const int PWM_MOTEUR_2 = 6;

const int EN_PIN_1 = A0;
const int EN_PIN_2 = A1;

// fonction d'initialisation de la carte
void setup()
{
    
    pinMode(Bouton1, INPUT);// initialisation de Bouton1 comme étant une entrée
    pinMode(Bouton2, INPUT);// initialisation de Bouton2 comme étant une entrée
    pinMode(Bouton3, INPUT);// initialisation de Bouton3 comme étant une entrée
    pinMode(Bouton4, INPUT);// initialisation de Bouton4 comme étant une entrée
   
    pinMode(LED, OUTPUT);// initialisation de LED comme étant une sortie
    
    pinMode(MOTEUR_A1, OUTPUT);// initialisation de MOTEUR_A1 comme étant une entrée
    pinMode(MOTEUR_B1, OUTPUT);// initialisation de MOTEUR_B1 comme étant une entrée
    pinMode(MOTEUR_A2, OUTPUT);// initialisation de MOTEUR_A2 comme étant une entrée
    pinMode(MOTEUR_B2, OUTPUT);// initialisation de MOTEUR_A2 comme étant une entrée
    pinMode(PWM_MOTEUR_1, OUTPUT);// initialisation de PWM_MOTEUR_1 comme étant une entrée
    pinMode(PWM_MOTEUR_2, OUTPUT);// initialisation de PWM_MOTEUR_2 comme étant une entrée
    pinMode(EN_PIN_1, OUTPUT);// initialisation de EN_PIN_1 comme étant une entrée
    pinMode(EN_PIN_2, OUTPUT);// initialisation de EN_PIN_2 comme étant une entrée

  
    digitalWrite(Bouton1, HIGH);// activation de la resistance de pullup
    digitalWrite(Bouton2, HIGH);// activation de la resistance de pullup
    digitalWrite(Bouton3, HIGH);// activation de la resistance de pullup
    digitalWrite(Bouton4, HIGH);// activation de la resistance de pullup
  
  
  
}

// fonction principale, elle se répète (s’exécute) à l'infini
void loop()
{
    
	int etatB1 = digitalRead(Bouton1); // lecture de l'état du bouton1 et stockage dans etatB1
	int etatB2 = digitalRead(Bouton2); // lecture de l'état du bouton2 et stockage dans etatB2
    int etatB3 = digitalRead(Bouton3); // lecture de l'état du bouton3 et stockage dans etatB3
    int etatB4 = digitalRead(Bouton4); // lecture de l'état du bouton4 et stockage dans etatB4

  
  
      // Si le bouton est "appuyé"
    if((etatB1==LOW)&&(etatB3==LOW))
    {
     
 
      digitalWrite(LED, LOW); //la LED est allumée  
        
      //allume moteur sens horaire
      digitalWrite(EN_PIN_1, LOW);
      digitalWrite(EN_PIN_2, LOW);

      digitalWrite(MOTEUR_A1, HIGH); 
      digitalWrite(MOTEUR_B1, HIGH);
      digitalWrite(MOTEUR_A2, LOW);
      digitalWrite(MOTEUR_B2, LOW);
      
      digitalWrite(PWM_MOTEUR_1, LOW);
      digitalWrite(PWM_MOTEUR_2, LOW);
     
    }
    else if((etatB2==LOW)&&(etatB4==LOW))
    {
     digitalWrite(LED, LOW); //la LED est allumée
  
     //allume moteur sens anti horaire
     digitalWrite(EN_PIN_1, LOW);
     digitalWrite(EN_PIN_2, LOW);
      
     digitalWrite(MOTEUR_A1, LOW);
     digitalWrite(MOTEUR_B1, LOW);  
     digitalWrite(MOTEUR_A2, HIGH);
     digitalWrite(MOTEUR_B2, HIGH); 
     digitalWrite(PWM_MOTEUR_1, LOW);              
     digitalWrite(PWM_MOTEUR_2, LOW);
    }
     
    else  
    {
      digitalWrite(LED, HIGH); //la LED est éteinte
     //Eteint le moteur
      digitalWrite(EN_PIN_1, HIGH);
      digitalWrite(EN_PIN_2, HIGH);
     
      digitalWrite(MOTEUR_A1, HIGH);
      digitalWrite(MOTEUR_B1, HIGH);    
      digitalWrite(MOTEUR_A2, HIGH);
      digitalWrite(MOTEUR_B2, HIGH);
      
      digitalWrite(PWM_MOTEUR_1, HIGH);
      digitalWrite(PWM_MOTEUR_2, HIGH);
    }

}

J’aimerai faire en sorte que quand le moteur tourne il s’arrete si un interrupteur ( 2 ou 4) est appuyé.

Concretement, si le bouton 1 et 3 est allumé, il allume le moteur en sens horaire tant que l’interrupteur 4 n’est pas appuyé.

idem pour l’autre cas de figure, si le bouton 2 et 4 est allumé, il allume le moteur en sens antihoraire tant que l’interrupteur 2 n’est pas appuyé.

je ne sais pas comment le retranscrire, je pense qu’il me faut une boucle, mais quelle type ? while ? do-while ? for ? à quel niveau je dois les inclure, et comment gérer les interrupteur/variable car les interrupteurs 2 et 4 sont utilisés plusieurs fois .

Je remet en PJ mon logigramme et une photo de mon montage test :slight_smile:

cordialement

Bonjour,

Tu n'as pas besoin d'utiliser 2 entrées pour un bouton

Il faut juste une variable boulean moteurtourne ou autre nom au choix, hors fonctions

et dans la fonction loop() :

if (!moteurtourne && !etatB1)//appui bouton moteur arrêté
{
  Action 1
  moteurtourne = true;
}

if (moteurtourne && !etatB1)//appui bouton en marche
{
  arret
  moteurtourne = false;
}

/les broches A1/B1 et A2/B2 sont soudé ensemble pour avoir plus de puissance, //ne pas oublier d'envoyer du courant en même temps dans les broches A1/B1 et A2/B2 //pour avoir toute la puissance moteur

Bonjour c'est une très mauvaise idée de relier des sorties arduino (pour avoir plus de puissance) et surtout c'est inutile.

la puissance va être donnée par le pont en H ! une sortie PWM permet de commander ce pont de 0 a 100% sans problème.

//ne pas oublier d'envoyer du courant en même temps dans les broches A1/B1 et A2/B2

c'est une très mauvaise idée de relier des sorties arduino (pour avoir plus de puissance) et surtout c'est inutile.

C'est même pire que ça:

    digitalWrite(MOTEUR_A1, HIGH);
    digitalWrite(MOTEUR_B1, HIGH);

Les ordres ne sont pas donnés en même temps. Entre les deux instructions, A1 est haut pendant que B1 est encore bas. C'est un court-circuit au niveau de l'arduino et au niveau des ponts. Si on voulait les changer en même temps, il faut utiliser les instructions d'accès direct aux ports (PORTA=...).

Si deux ponts ont leurs sorties reliées ensembles, il faut relier leurs entrées ensembles, et utiliser une seule pin de l'Arduino, voir réponse #3

Achess : c'est à dire que j'utilise 2 entrée pour un bouton ? pour le montage j'ai besoin d'avoir 2 boutons activés pour activer le moteur

Je ne comprend pas trop à quoi ça sert de rajouter la variable booléenne ? le if que tu me donnes c'est à inclure dans ma boucle avec etatB1/etatB3 pour gérer le 3ieme bouton fin de stopper le moteur?

JFS59 : Si je branche le moteur uniquement sur les pin A1 et B1 du shield moteur, que je met le PWM à 100% ( soit 255 comme valeur) le moteur tourne qu'à moitié de sa puissance

JFS59 et vileroi : ce n'est pas les pin de l'arduino qui sont relié ensemble mais les pin de sortie du shield moteur afin de faire le montage de la réponse #3 :

|500x272

C'est juste que j'ai pas relié les pins de contrôle physiquement, je pensais qu'en les activant "en même tant" ça reviendrai au même que de les relier physiquement.

En théorie oui les 2 pin ne sont pas connecté en même tant, après ça revient à allumer le moteur à 50% puis 100% non ? après oui je peux les relier ensemble ça évitera de doubler mes lignes donc programme plus simple :) par contre j'ai soudé les broches sur le shield moteur afin de l'embrocher sur l'arduino, donc si je relie les 2 pin coté shield ça revient à relier les 2 pin coté arduino aussi, donc je dois couper une broche afin de n'avoir qu'une pin coté arduino qui contrôle le shield.

Bonjour, j'ai effectué un travail il y a quelques mois pour le contrôle de motoréducteurs 12volts 10A à l'aide de Commande de moteur CC 12A DRI0042 chez Go Tronic qui sont à un tarif raisonnable. Ils sont simple d'utilisation et très fiable (attention tout de même à ce qu'il n'y est pas de jeux dans les borniers moteur et arrivée d'alimentation sinon risque de surchauffe du aux mauvais contact avec fonte de ceux-ci). Pour la commande des moteurs j'ai utilisé un clavier matriciel. En plus de micro swicht pour les fin de course j'avais ajouté une sécurité en temps écoulés. Actuellement je travail sur le développement d'un autre système presque identique. Gestion de 5 vérins électrique commander par une interface web sur Raspberry pi via la carte Arduino pour une commande à distance et sur l'installation même des commandes par boutons pour un contrôle manuel si nécessaire.

Pour la gestion des boutons dans ton cas ajoute un drapeau comme quoi tu as activé le moteur dans un sens : Si bouton 1 et 2 appuyés : tu va dans une fonctionne de type

    void fonctionSensHoraire(){
    digitalWrite(sensHoraire, HIGH);
    digitalWrite(sensAntiHoraire, LOW);
    digitalWrite(vitesseMoteur, 255);
    drapeauSensHoraire = true;
}

puis si bouton 4 appuyer et drapeauSensHoraire à true tu va dans la fonction arrêt du moteur

    void fonctionArretMoteur(){
    digitalWrite(sensHoraire, LOW);
    digitalWrite(sensAntiHoraire, LOW);
    digitalWrite(vitesseMoteur, 255);
}
    drapeauSensHoraire = false;

Ce n'est pas les pin de l'arduino qui sont relié ensemble mais les pin de sortie du shield moteur afin de faire le montage de la réponse #3 :

C'est juste que j'ai pas relié les pins de contrôle physiquement, je pensais qu'en les activant "en même tant" ça reviendrai au même que de les relier physiquement.

En théorie oui les 2 pin ne sont pas connecté en même tant, après ça revient à allumer le moteur à 50% puis 100% non ?

Le shield est composé de deux ponts et chacune des 4 sorties se compose d'un transistor entre le +12V et la sortie et d'un transistor entre le 0V et la sortie. Si on veut du 12V on rend passant le premier et si on veut du 0V on rend passant le second. Ce n'est pas si on veut du 0V on ne fait rien passer. Ici en demandant du 0V la sortie se comporte comme un court-circuit. Sinon on ne pourrait pas faire tourner un moteur dans les deux sens.

En ayant deux sorties branchées ensembles, l'une (celle qui doit donner du 12V) relie la sortie au 12V, et l'autre (qui doit ête à 0V) relie la sortie au 0V. Du coup il y a un court-circuite entre le 12V et le 0V via le pont et ses transistors. Si le temps est très court, cela peut passer, Pour moi, ça fait 4µs.

D’emblée, ce n'est vraiment pas à conseiller. Mais il y aura un gros problème si il y a une erreur de programmation, ou pour une autre raison (le programme se plante parce qu'il déborde, on l'arrête parce que l'on recharge au mauvais moment...)

inflames29: C'est juste que j'ai pas relié les pins de contrôle physiquement, je pensais qu'en les activant "en même tant" ça reviendrai au même que de les relier physiquement.

bonjour, c'est pas forcement une bonne idée voir ici un fil sur le même sujet

re bonjour deux choses

si avec un pwm a 100% (255) le moteur tourne a 1/2 vitesse c'est qu il y a un autre probleme !

a 100% la tension de sortie du pont est a peut de chose prêt celle de son alim !

en cas de manque niveaux courant (pont un peu juste ) on peut relier deux pont en // mais il faut absolument que les entrées des deux ponts soient commandées par un signal unique (les entrées de pont doivent être reliées physiquement) et une seule sortie arduino envoye le pwm de commande !mme la c plusieurs entrees (inversion etc ...) les entrees des ponts doivent etre reliees par paires equivalente ! et les sorties bah idem

inflames29: Achess : c'est à dire que j'utilise 2 entrée pour un bouton ? pour le montage j'ai besoin d'avoir 2 boutons activés pour activer le moteur

Je ne comprend pas trop à quoi ça sert de rajouter la variable booléenne ? le if que tu me donnes c'est à inclure dans ma boucle avec etatB1/etatB3 pour gérer le 3ieme bouton fin de stopper le moteur?

Non, elles évitent de répéter inutilement une commande et peuvent permettre d'utiliser un seul bouton pour commander la rotation d'un sens et de l'autre, ainsi que l'arrêt d'urgence.