30 moteurs DC en simultané

Bonjour à tous !

Je travaille sur un projet nécessitant d'utiliser 30 moteur en simultané.
Le principe est assez simple : je souhaite utiliser ces moteurs (Motoréducteur 50:1 FIT0482 DFRobot - Motoréducteurs + encodeurs | GO TRONIC) avec un encodeur relatif intégré, leur envoyer chacun une "target" (distance de rotation) propre, puis leur envoyer à tous une target zéro pour qu'il reviennent à leur position d'origine. Je précise qu'il sont destinés à faire tourner des vis imprimé en 3D d'environ 1 cm de diamètre, sans réel poids ou contrainte (les vis font juste bouger un boulon lui aussi en plastique de haut en bas). Je sais aussi que parce que l'encodeur n'est pas absolue, la position zéro serra celle du démarrage, mais ce n'est pas un problème, j'ai déjà fait un test avec deux moteurs et le résultat me convient.

Pour le reste du matériel je prévois d'utiliser une arduino MEGA 2560, 5 x MCP23017 (https://www.microchip.com/en-us/product/mcp23017) en I2C pour atteindre un total de 134 pin (d'après mes calculs j'ai besoin d'en avoir 120 : 2 pin moteur et 2 pin encodeur par moteur) et des L298N comme driver moteur (Tutoriel L298N : fonctionnement, branchement, code arduino). J'ai conscience que je n'aurais pas de sortie PWM mais je n'ai pas vraiment besoin de contrôler la vitesse des moteurs, seulement le sens.

Niveau code j'ai repris celui-ci : https://create.arduino.cc/projecthub/curiores/how-to-control-multiple-dc-motors-with-encoders-f8ed6c?ref=user&ref_id=1603528&offset=2
Pour l'instant je l'ai adapté pour fonctionner avec un shield L293D et cela fonctionne bien.

Étant donné que je n'ai jamais eu de formation sur tout ces sujets je voulais savoir si sur le papier, ce projet peux fonctionner avec ce matériel. J'ai déjà demandé sur le forum anglais mais je me suis plutôt fait descendre sur mon manque de connaissance qu'autre chose...

Mon deuxième questionnement est comment j’alimente correctement tout ça sans prendre de risque. Je sais que je devrais calculer avec la loi ohm le "courant de calage" ou de démarrage des moteurs, mais j'ai du mal à m'en sortir avec ce que je trouve sur internet, dans le sens où j'ai deux inconnues dans l'équation.

J’espère que je n'ai rien oublié, dites moi si besoin je reste réactif.
Merci !

Je ne connais pas bien le mega, je pense que si tu utilise un µC pouvant faire tourner FreeRTOS, ça pourrait t'aider ?

J'avoue ne pas connaitre du tout cela :sweat_smile: Quel en serait l'application ? Cela servirai à remplacer l'arduino ?

pourquoi ne pas prendre des moteurs pas à pas ( par exemple du genre 28BYJ-48 avec leur ULN2003)

vous en avez 5 pour 19€ et on trouve sans doute moins cher en chine

Pour moi il y a une inconnue supplémentaire : combien de moteurs sont-ils susceptibles de tourner en même temps, et également de démarrer en même temps ?
Pour le moteur cité le fabricant donne un courant en charge de 170mA, mais tout dépend de la charge. Il manque une indication du courant de blocage (le courant de démarrage sera assez proche), à mesurer donc.
Si une alimentation à découpage est choisie, au moindre dépassement de son courant maximal elle va couper sa sortie, contrairement à une alimentation linéaire, qui, si le dépassement est raisonnable, va encaisser la surcharge avec une petite baisse de tension.

J'ai opté pour des moteurs DC pour limiter la multiplication des pins et pour leur vitesse de rotation supérieur aux moteurs pas à pas (sans pour autant avoir besoin d'une vitesse super élevé).

Pour l'inconnu supplémentaire : tout les moteurs vont tourner et potentiellement démarrer en même temps. Effectivement il me manque le courant de blocage et c'est justement pour ça que je voulais savoir si vous connaissiez un tuto ou autre qui explique clairement comment le mesurer.
Merci pour l'indication sur le type d'alimentation, je vais certainement opter pour une alimentation linéaire. :slight_smile:

Le courant de blocage devrait être égal à U / R.
U = 6V.
R = résistance du bobinage.

Difficile à trouver, et chère, à moins de la réaliser soi-même.
Il est possible aussi d'opter pour une alimentation à découpage surdimensionnée.

J'ai peur que vous pensiez que je fais exprès mais comment je peux calculer ou mesurer la résistance du bobinage ? :melting_face:

Mais ça peut rapidement le devenir.

  • Si le système se plante, les moteurs vont s'arrêter n'importe où et au démarrage ils ne seront plus à leur position de départ habituelle.
  • Avec le temps, un moteur va tourner un peu moins vite que les autres et puis 2 et puis 3 et au final ils seront tous décalés.

Avec un ohmmètre.

oui et les vis/boulons imprimés en 3D vont aussi prendre du jeu

Merci pour tout vos conseil.

Effectivement j'ai conscience que l'encodeur relatif peut causer ces problèmes, et c'est vraiment sympa de me prévenir, mais pas d'inquiétude : je vais faire en sorte de pouvoir retirer les vis des moteurs facilement en cas de plantage (pour pouvoir revisser les boulons dessus), et pour la vitesse je ne les faits pas tourner très longtemps. Quand vous dites avec le temps, vous voulez dire de jours en jours voir semaine/mois ? Car ça ne serra pas utilisé tout les jours (même surement rarement).

En fait ce projet est plus un proto pour démontrer un fonctionnement. Il servira de démonstration et va surement finir sur une armoire, donc avant d'user les vis je pense que j'ai une bonne marge.

Mais sachez que je note tout ces problèmes et potentiels améliorations pour une prochaine version future (avec du meilleur matos) :grin:

Bonjour absent666

Un moteur DC avec codeur incrémental et commande par L298, c'est minimum 4 fils. Le codeur incrémental nécessite 2 entrées avec interruption et via le MCP23017, pour autant que je sache, ce n'est pas possible. Regardes l'exemple que tu cites:

  attachInterrupt(digitalPinToInterrupt(enca[0]),readEncoder<0>,RISING);
  attachInterrupt(digitalPinToInterrupt(enca[1]),readEncoder<1>,RISING);

Je plussoie @J-M-L, ce serai mieux avec des moteurs pas à pas.
Un moteur pas à pas avec un driver de type A4988, c'est 2 fils de commande DIR et STEP

Avec des moteurs pas à pas, ce serait presque plus intéressant de faire ceci, avec plusieurs Arduino, afin de commander directement les drivers. Les Arduino seraient reliés par un bus i2C.

A+
Cordialement
jpbbricole.

Oui je n'ai pas mentionné le A4988 car ça faisait plus cher mais si ce n'est pas un point important, c'est envisageable oui. Avoir plusieurs arduino ça permet d'utiliser les bibliothèques habituelles mais ça complexifie un peu la solution (même si ça la rend modulaire)

Sinon on pourrait utiliser des TPIC6B595 au lieu des ULN2003, on peut piloter 2 steppers avec un seul de ces modules et on peut les chaîner donc en en mettant 15 en série vous gérez vos 30 moteurs avec 2 pins. bien sûr il faudra coder sa propre bibliothèque pour gérer les moteurs

il y a eu plusieurs discussions sur le forum pour des sculptures Cinétiques (chercher "Kinetic sculpture")

Oui, sans problème. La librairie AdaFruit possède une méthode :

Mais ce ne sera certainement pas aussi réactif qu'une interruption directe, puisqu'il faut déterminer la pin responsable de l'interruption à l'aide d'une requête I2C.
Avec 5 MCP23017, ce sera encore moins rapide, sauf que la MEGA possède 6 pins d'interruption (2, 3, 18, 19, 20, 21). Mais les pins I2C sont 20 et 21.

Avec tout vos exemple je comprend bien que les moteurs pas-à-pas présente beaucoup d'avantages, malheureusement j'ai vraiment besoin que les moteurs fassent une certaines tailles et aillent à une certaines vitesse (je me doute qu'à cause des requêtes I2C il va y avoir un temps de réaction plus long) car l'objectif final ressemble beaucoup à celui de la discussion partagé par @J-M-L (Search results for 'Kinetic sculpture' - Arduino Forum), mais imaginons avec des vis de 1cm de diamètre quasiment collé les unes aux autres.

@hbachetti Si il est possible de faire des interruptions avec les MCP23017 ça m'arrange beaucoup j'avoue.

Vous avez d’ailleurs soulevé un mystère assez bizarre dans mon code : j'ai remarqué que le pin enca[1] n'était pas raccordé sur une entrée avec interruption, pourtant il fonctionne bien, voir même il fonctionne moins bien quand je le mes sur une avec interruption. Je peux expliquer plus en détail si cela intéresse des curieux.

Bonjour absent666

Oui, @hbachetti parle la possibilité du MCP23017 de générer des interruptions "simples", mais quand à gérer les interruptions d'un codeur incrémental et ce de plusieurs moteurs, ce n'est pas utilisable, même pas pour un seul moteur. Seul la liaison directe sur l'Arduino est plausible.

Dans ma proposition i2C, l'idée était d'avoir des unités Arduino autonomes gérant complètement x moteurs et recevant les ordres de position d'un Arduino maître. Ainsi, la latence du bus devient négligeable. L'Arduino maître pourrai, également, gérer des moteurs.

Cordialement
jpbbricole

quelle taille et quelle vitesse ?

Ok je vois @jpbbricole , est-ce que supprimer de l'équation les MCP23017 et les remplacer par des arduino mega, tout en gardant les moteurs dc, serait alors une meilleurs solution ? Je n'ai pas vraiment trouvé de moyen d'ajouter des ports à interrupteur externes, est-ce que ça existe ? (je suis curieux).

Le modèle de moteurs que j'ai choisi font environ 1,5x1,2x3 cm seulement, avec une rotation de 310 tr/min sans charge et 180 tr/min avec (sachant qu'il ne seront quasiment pas contraints), plus gros et/ou plus lent serait un peu handicapant malheureusement.

Bonsoir absent666

Excellente qualité :wink:

Pour moi, oui,
Sur un Mega, INT0 et INT1 sont occupés par le bus i2C, il reste INT2, INT3, INT4 et INT5.
Bien que le codeur incrémental aie 2 sorties A et B, seul une nécessite une interruption, on diminue simplement la résolution de comptage mais qui reste certainement suffisante. Ainsi, sur un Mega on pourrai avoir 4 moteurs.
Sur un UNO ou Nano il y a INT0 et INT1 donc 2 moteurs.
Reste à savoir ou à essayer, il existe des bibliothèque qui permettent les interruptions sur toutes, ou presque presque toutes les pin de l'Arduino, ce système est-il assez rapide pour gérer des codeurs incrémentaux?
Je peux, si nécessaire, essayer.

Cordialement
jpbbricole

Ou envisager de confier la gestion du codeur à une bibliothèque comme Encoder.h ?

Cordialement
jpbbricole