Tourner un disque avec un moteur à pas

Bonjour, j'essaye de faire trouner un disque avec un moteur à pas. Je vais fixer le disque directement sur le moteur, en horizentale, un peut comme un lecteur de disque. Le Ncm du moteur est égale à 26. Es ce qu'on peut savoir d'avance si le moteur sera capable de faire tourne un disque d'un diametre de 50cm et d'un poids de 500g? C'est quoi le calcul à faire? Merci

Il y a deux problèmes complètement indépendants:

  1. Le poids du disque va porter sur les roulements du moteur
  2. Il faut entrainer le disque en rotation

Pour le premier point, en général on n'a pas l'effort axial qu'est capable d'encaisser le moteur. Plus le moteur est chargé, plus sa durée de vie diminue, mais sans doc constructeur, on ne peut pas dire grand chose.

Pour le deuxième point, il faut vaincre les frottement secs du moteur (principalement du aux roulements qui son chargés) et l'inertie. L'inertie qui dans ce cas est importante, va imposer une vitesse de démarrage assez faible, mais si on peut accélérer le mouvement, cela ne limitera pas la vitesse.
Le calcul du démarrage n'est pas simple du tout. Le couple moteur peut être approximé par une sinusoïde en fonction du décalage:
Couples_coupleStatique
On peut avoir au maximum un décalage de 2pas (1/100ème de tour), mais alors on n'a plus de couple. Il faut en gros compter que l'on peut passer au pas suivant que quand le moteur a avancé d'un pas... Bon courage.

Dans la pratique, on essaye avec une certaine accélération, et si on perd des pas, on diminue l'accélération.
Je pense sincèrement que la vitesse limite (inertie très importante mais frottement assez faibles) dépend plus de la mécanique que du moteur. Au delà d'une certaine vitesse le disque va se mettre à vibrer. Sinon, je pense que l'on peut aller au moins à 1000tr/mn si on accélère lentement. Sans accélération peut-être 1tr/mn. Mais l'expérience est plus simple et plus rapide que le calcul pour le commun des arduinoistes.

Faire tourner un disque de 500 kg, oui, mais à quelle vitesse angulaire ?
Quelle mécanique ? Il y a-t-il un " ~système" de roulement ?

J'ai comme une idée que le nombre de tours par minute ne va pas être élevé dans ce cas un système de démultiplication serait peut-être le bienvenu.

Cherchez l'erreur :wink:

Oh on est pas à un "k" près, :grinning: , d'accord cela change tout :unamused:.

L'indication de vitesse angulaire cherchée est quand même (un petit peu) utile.
La fixation aussi, s'il y a du balourd, ce sera un peu compliqué.

Merci beaucoup @vileroi pour l'explication, c'est très instructif. Je reçoit demain le matériel n'écessaire et je vais simplement voir en pratique ce que cela donne.

@68tjs Mes connaissances sont très limiter en mécanique, donc je vais commencer par tester la solution la plus simple à mettre en place, voir fixer le disque sur le moteur avec quelque chose comme ça. Si cela ne marche pas je vais voir les options de démultiplication disponible.

Ça n'est sans doute pas nécessaire, mais il ne faut pas démarrer à fond, il faut accélérer progressivement.

J'utilise un moteur à pas piloter par une Shield Adafruit. Il n'y a pas vraiment d'option pour ajuster la vitesse. Mon Code ressemble à ça


for i in range(100):
    kit.stepper1.onestep(direction=stepper.FORWARD, style=stepper.DOUBLE)
    time.sleep(0.01)
time.sleep(1)
for i in range(100):
    kit.stepper1.onestep(direction=stepper.BACKWARD, style=stepper.DOUBLE)
    time.sleep(0.01)

Accélérer progressivement veut dire au début augmenter la pause entre les pas? Genre time.sleep(0.10) pour les premier 10 pas et puis diminuer au fur et a mesure?

C'est celui ci le shield?

Exact. Pour avoir une accélération constante, il faut que les temps soient avec des valeurs en 1/√N  N étant le numépo du pas. On peut aussi accélérer en faisant des paliers (moins de calculs à faire).
Pour 128 pas ou 128 paliers, j'utilise la table:

const float vitesse[128] = {
11.357817, 8.031189, 6.557439, 5.678908, 5.079370, 4.636809, 4.292851,
4.015595, 3.785939, 3.591657, 3.424511, 3.278719, 3.150092, 3.035504,
2.932576, 2.839454, 2.754675, 2.677063, 2.605662, 2.539685, 2.478479,
2.421495, 2.368268, 2.318405, 2.271563, 2.227451, 2.185813, 2.146426,
2.109094, 2.073644, 2.039924, 2.007797, 1.977142, 1.947849, 1.919821,
1.892969, 1.867214, 1.842481, 1.818706, 1.795828, 1.773793, 1.752549,
1.732051, 1.712255, 1.693123, 1.674619, 1.656708, 1.639360, 1.622545,
1.606238, 1.590412, 1.575046, 1.560116, 1.545603, 1.531488, 1.517752,
1.504380, 1.491354, 1.478662, 1.466288, 1.454219, 1.442444, 1.430950,
1.419727, 1.408764, 1.398051, 1.387578, 1.377338, 1.367320, 1.357519,
1.347925, 1.338532, 1.329332, 1.320319, 1.311488, 1.302831, 1.294343,
1.286019, 1.277854, 1.269843, 1.261980, 1.254261, 1.246682, 1.239239,
1.231928, 1.224745, 1.217686, 1.210747, 1.203926, 1.197219, 1.190623,
1.184134, 1.177751, 1.171469, 1.165287, 1.159202, 1.153212, 1.147313,
1.141504, 1.135782, 1.130145, 1.124591, 1.119119, 1.113726, 1.108409,
1.103169, 1.098002, 1.092906, 1.087882, 1.082925, 1.078036, 1.073213,
1.068454, 1.063757, 1.059122, 1.054547, 1.050031, 1.045572, 1.041169,
1.036822, 1.032529, 1.028288, 1.024100, 1.019962, 1.015874, 1.011835,
1.007843, 1.003899};

Au début, je vais 11 fois plus lentement, à la fin j'ai la vitesse fois 1. Pour arriver à un temps 0,01, je commencerai à 0,1135.

Pour copier une image tu colles simplement l'URL dans une ligne vide

1 Like

Exactement, mais là je travaille avec la carte pour Raspberry Pi pour plus de flexibilité
Merci beaucoup, très bonne idée.

C'est le même driver. Seulement avec un Raspberry, je en peux pas te conseiller pour un programme ou pour une bibliothèque. Juste sur le principe.

Il faudrait aller sur un forum plus adapté.

es ce que mon code pour calculer l'accélération est correcte?

def makeSteps(stepsNumber):
    print("moving, number of steps: ", stepsNumber)
    for i in range(stepsNumber):
        kit.stepper1.onestep(direction=stepper.FORWARD, style=stepper.DOUBLE)
        time.sleep(1 / sqrt(i + 60))

Pour 128 pas, le résultat est le suivant

sleep 0.12909944487358055
sleep 0.12803687993289598
sleep 0.1270001270001905
sleep 0.1259881576697424
sleep 0.125
sleep 0.12403473458920847
sleep 0.12309149097933272
sleep 0.12216944435630522
sleep 0.12126781251816648
sleep 0.1203858530857692
sleep 0.11952286093343936
sleep 0.11867816581938533
sleep 0.11785113019775793
sleep 0.11704114719613057
sleep 0.11624763874381928
sleep 0.11547005383792514
sleep 0.11470786693528087
sleep 0.11396057645963795
sleep 0.11322770341445956
sleep 0.1125087900926024
sleep 0.11180339887498948
sleep 0.1111111111111111
sleep 0.11043152607484653
sleep 0.10976425998969035
sleep 0.1091089451179962
sleep 0.10846522890932808
sleep 0.10783277320343841
sleep 0.10721125348377948
sleep 0.10660035817780521
sleep 0.105999788000636
sleep 0.10540925533894598
sleep 0.10482848367219183
sleep 0.10425720702853739
sleep 0.10369516947304253
sleep 0.10314212462587934
sleep 0.10259783520851541
sleep 0.10206207261596577
sleep 0.10153461651336192
sleep 0.10101525445522107
sleep 0.10050378152592121
sleep 0.1
sleep 0.09950371902099892
sleep 0.09901475429766744
sleep 0.09853292781642932
sleep 0.09805806756909202
sleep 0.09759000729485333
sleep 0.09712858623572641
sleep 0.09667364890456635
sleep 0.09622504486493763
sleep 0.09578262852211514
sleep 0.09534625892455924
sleep 0.0949157995752499
sleep 0.0944911182523068
sleep 0.09407208683835973
sleep 0.0936585811581694
sleep 0.09325048082403138
sleep 0.09284766908852593
sleep 0.09245003270420485
sleep 0.09205746178983235
sleep 0.09166984970282113
sleep 0.09128709291752768
sleep 0.09090909090909091
sleep 0.09053574604251853
sleep 0.09016696346674323
sleep 0.08980265101338746
sleep 0.08944271909999159
sleep 0.0890870806374748
sleep 0.08873565094161139
sleep 0.08838834764831843
sleep 0.08804509063256238
sleep 0.08770580193070293
sleep 0.0873704056661038
sleep 0.08703882797784893
sleep 0.086710996952412
sleep 0.08638684255813601
sleep 0.08606629658238704
sleep 0.08574929257125441
sleep 0.0854357657716761
sleep 0.08512565307587486
sleep 0.08481889296799709
sleep 0.08451542547285165
sleep 0.0842151921066519
sleep 0.08391813582966891
sleep 0.08362420100070908
sleep 0.08333333333333333
sleep 0.08304547985373997
sleep 0.0827605888602368
sleep 0.08247860988423225
sleep 0.08219949365267865
sleep 0.08192319205190406
sleep 0.08164965809277261
sleep 0.08137884587711594
sleep 0.08111071056538127
sleep 0.08084520834544433
sleep 0.08058229640253803
sleep 0.08032193289024989
sleep 0.08006407690254357
sleep 0.07980868844676221
sleep 0.079555728417573
sleep 0.07930515857181442
sleep 0.07905694150420949
sleep 0.07881104062391006
sleep 0.07856742013183861
sleep 0.07832604499879574
sleep 0.07808688094430304
sleep 0.0778498944161523
sleep 0.07761505257063328
sleep 0.07738232325341368
sleep 0.07715167498104596
sleep 0.07692307692307693
sleep 0.07669649888473704
sleep 0.07647191129018725
sleep 0.07624928516630233
sleep 0.07602859212697055
sleep 0.07580980435789034
sleep 0.07559289460184544
sleep 0.07537783614444091
sleep 0.07516460280028289
sleep 0.07495316889958614
sleep 0.07474350927519359
sleep 0.07453559924999299
sleep 0.07432941462471664
sleep 0.07412493166611012
sleep 0.07392212709545729
sleep 0.07372097807744857
sleep 0.07352146220938077
sleep 0.07332355751067665
sleep 0.07312724241271307

Ce qui est bizarre c'est que le tout premier pas ce fait dans le sense contraire avec se code. Mais si j'éxécute la function une deuxieme fois, cela fonctionne plus au moin bien.

Pour N pas mes valeurs doivent être si Vm est la vitesse finale

time.sleep(Vm / sqrt(i / N))

J'utilise 129 pas (table de 128 valeurs, la 129ème c'est Vm)
Pour retrouver ma table, genre:

for i in range(128):
      print("1 / sqrt(i / N))

sqrt 0/128 = 0
1/0 ça donne erreur. C'est ok si j'utilise print("1 / sqrt(i +1 / N))?

Effectivement, je commence au pas 1!

Merci beaucoup, je vais tester :wink:

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.