bonjour , à tous est ce que quelqu'un saurait comment integrer une ramp d'accel/decell pour un moteur pas a pas
et un code "simple", pour lui donner le nombre d'impulsion voulu en consigne?
merci
Bonjour,
une simple petite recherche pourrait donner ceci
avec un exemple concret a étudier
ensuite sans rien savoir des temps , des moteurs , de l’électronique de commande et sans un minimum de proposition de programme il est difficile de répondre
cordialement
oui désolé
en fait je cherche juste a faire un signal pulse/dir
pour piloter des drivers externe de moteur pas a pas
selon l etat de dir (haut ou bas), on va dans un sens ou l autre
et pour pulse, une impulsion=1 pas
donc un enchainement d impulsion donne un mouvement du moteur, ou deplacement d'un axe si il est relié à une machine
tout les controleurs que j'utilise, on leur donne une consigne d'acceleration/deccelleration
ça peut être par exemple un temps en milliseconde, qui est le temps pour arriver à la vitesse max, et idem pour la deccelleration, mais ça peut etre ce que l'on veut, tanr qu'on puisse les faire varié pour avoir un mouvement doux
ensuite, la longueur totale du train d'impulsion, ce defini par un nombre d'impulsion total , il comprend l accelleration et la deccelleration
cela permet à partir d'un arduino, de piloter des moteurs pas a pas ou servo moteur industriel
merci, par contre je suis pas un codeur fou, donc j avoue ne pas tout bien comprendre
si je veux juste lancer un mouvement sur un driver
avec une acceleration de 2 seconde, une deccelleration de 3 seconde, et un mouvement total de 200 pas
ça donnerais quoi?
vtec35:
merci, par contre je suis pas un codeur fou,
…avec une accélération de 2 secondes, une décélération de 3 secondes, et un mouvement total de 200 pas, ça donnerait quoi?
Ce n’est pas une histoire de codage. C’est un amusant petit problème de mécanique.
Soient Aa, l’accélération, Ad la décélération et Vmax la vitesse max tolérée.
Soient ta la durée d’accélération, td la durée de décélération et tx la durée à Vmax.
La vitesse max est atteinte au bout de Aa x ta soit Vmax = Aa x ta.
Pour arriver à vitesse nulle, la décélération doit provoquer une perte de vitesse ègale à celle acquise pendant l’accélération, soit Ad x td = Aa x ta
Le parcours total de 200 pas est obtenu par la somme des parcours pendant l’accélération, la phase à vitesse constante et la décélération, soit :
200 = Aa x ta2 / 2 + Ad x td2 / 2 + Vmax x tx
En secouant tout ça, on obtient : tx = 200 / Vmax - (ta + td) / 2
NOTA: La vitesse tolorée peut ne pas être atteinte si : 200 / Vmax - (ta + td) / 2 < 0
Je vous laisse faire l’application numérique.
Cordialement.
Pierre
ok, mais à la fin il faut tout de même le coder
je vais essayer
bonjour, on a regardé un peu la librairie, et on ne voit pas trop comment l'utiliser
Compte tenu de ce que vous nous répondez, la question qu'on peut se poser est : que savez-vous faire ?
Les intervenants de ce forum ne sont pas là pour vous apporter une solution toute faite.
Si votre problème est la programmation d'un Arduino, je vous conseille de regarder ces tutos. Vous y apprendrez à utiliser une bibliothèque.
Quand vous aurez un morceau de code que vous aurez un peu travaillé, proposez-le nous avec des questions sur ce qui ne fonctionne pas.
Cordialement.
Pierre
alors mon ami est programmateur, mais on debute en arduino
on a deja realisé un programme un peu complexe, avec l’utilisation des données d’une balance via un port serie, et une sucession d’etape qui pilote des sorties et un ecran lcd
il nous reste juste à integrer le deplacement d’un moteur pas à pas , sans que celui ci soit trop brutal et sur un nombre de pas précis
Je viens de faire un banc de test pour moteur PAP.
L’idée est de pouvoir lancer un moteur avec sa charge et voir à partir de quelle vitesse il déraille, quelle accélération il supporte etc etc.
J’ai rajouté un contrôle du courant, car si on double le courant dans les bobines, on multiplie par 4 la vitesse max théorique. Il faut donc prendre ça en compte.
Les belles formules que l’on trouve à partir d’une accélération linéaire sont jolies, certes, mais ne font que s’approcher de la réalité : on ne peut pas modifier la vitesse linéairement, c’est obligatoirement en marche d’escalier.
J’ai donc résolu la chose dans un tableau de vitesses que je remplis à chaque modification d’une donnée (vitesse ou accélération). Ce tableau a une taille fixe (64 x 16 bits de mémoire). Ce tableau contient les valeurs à mettre dans le registre TOP du timer qui gère le cadencement des pas.
Pour remplir ce tableau, à partir de la vitesse min (départ), vitesse max et accélération linéaire, je calcule en même temps N : le nombre de pas au bout duquel je passe à la vitesse supérieure.
Résultat : je sais qu’il me faudra N x (64 - 1) pas pour arriver à Vmax, idem pour la décélération (j’ai volontairement choisi de faire accélération = décélération pour des raisons évidentes de taille de mémoire).
Avant de lancer le moteur, je calcule à partir de quelle position je dois commencer à décélérer (pos_target - distance_accel). Je sais alors quelle sera la vitesse max pour de petits déplacements, une estimation du temps que prendra le parcours etc etc.
Au final, la majorité des formules sont super simples, à part le remplissage du tableau qui prend 1/2 seconde (tous mes calculs sont en float, car les valeurs passent par fois par des 10-6 ou 109).
C’est un petit exercice mathématique assez rigolo (une bonne soirée de noircissage de pages, ça rappelle l’école).
en fait pour le moment on deplace le moteur avec cette fonction
analogWrite(11, 127);
digitalWrite(DIR, HIGH);
mais bon ça n envoi que un mouvement permanent...
sur les autres automates que je code, j ai beaucoup moins mal à la tête
j'ecrit
moveaxe 1(numero de l axe),100(accel),10000(vitesse),200(deccell),3000(nombre de pas)
et hop j ai mon deplacement
là, j'ai lu en large et en travers la bibliotheque steppers avec l'anglais que je comprend, j'ai mal au crane
Suite à ton MP, je rebalance ici.
En gros, j'aime bien arduino, car un clique, et hop, ça tourne. Je n'aime pas arduino, car ça fait foirer toute la puissance du proc, tellement c'est fait pour les débutants.
Dans le fichier ci-dessous, tu verras jusqu'où j'ai du aller pour gérer mon petit moteur...
http://pop.studio.free.fr/imgtmp/pap_0.h
pap_0.h contient donc la gestion du moteur. comme ce code est lié à un ensemble de 2800 lignes de code, tout n'y est pas et tout seul, il ne marchera pas. J'espère seulement que le peu de commentaires t'aideront à y voir plus clair...
Si tu es patient, une prochaine version (d'ici un mois) sera plus loquace et plus "portable"...
Pour résumer, j'utilise un timer 16 bits. Un timer, c'est un compteur qui tourne tout seul dans son coin et provoque des interruptions à intervalles réguliers. Du coup, quelque soit ton programme, il sera interrompu au bon moment pour générer une impulsion qui fera avancer ton moteur d'un pas. Chose que ne font bien sûr pas les libs du net qui utilisent des usines à gaz chronovores, alors qu'un simple timer fait des miracles, et qu'il y en a 3 sur la UNO, 6 sur la MEGA...
Avec ce code (plus gestion d'un minitel en guise de terminal, surveillance de fins de courses, LCD 16x2 en temps réel), je peux pousser mon moteur à 7500 pas par seconde (pas essayé plus, car je trouve que faire avancer un pont de CNC qui pèse 8kg à 10cm/s, ça me va très bien pour un moteur sous 24V / 2A). La seconde version en cours me permettra d'aller encore plus vite, à l'aide d'un joystick (j'ai craqué, 40€ pour un 3 axes, idéal pour piloter une CNC en manuel).
Bref, je ne peux qu'aider un programmeur qui connait les architectures de processeurs, pas un débutant car j'aborde des notions très... hard...
et si on s inspire des cnc chinoise avec carte mega
il utilise quoi comme code pour piloter leur driver?
on doit bien pouvoir s inspirer de ça.
si je regarde un peu ton code en travers il esg fait pour piloter un moteur en direct
c est a dire que tu dois gerer la syncro pour 4 fils simultanement?
edit:
je pense que je vais tenter un truc simple avec 2 timer
3etape
l acceleration avec un timer qui boucle toutes les 10ms par exemple et qui augmente la vitesse jusqu a v max, une fois v max atteint
on passe a l etape 2 et timer 2
v stable puis etape 3 timer 1 a nouveau qui fera l inverse jusque 0
question comment faire un timer qui va boucler toute les x ms sans etre bloquant pour le reste du programme
bon premiere avancé pour moi
tout seul j ai fait ça
#include <LiquidCrystal.h>
unsigned long time;// Variables pour utiliser l’écran
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // Définir les pins utilisées par le LCD
int lcd_key = 0;
int adc_key_in = 0;
#define btnRIGHT 0
#define btnUP 1
#define btnDOWN 2
#define btnLEFT 3
#define btnSELECT 4
#define btnNONE 5void setup(){
Serial.begin(9600);
lcd.begin(16, 2); // Démarrer la librairie écran
lcd.setCursor(0,0);
lcd.print(" “);
lcd.setCursor(0,1);
lcd.print(” ");
}
void loop(){
Serial.print("Time: ");
time = micros();lcd.setCursor(0,0);
lcd.print(micros());
lcd.setCursor(0,1);
lcd.print(" ");Serial.println(time); //prints time since program started
//delay(1000); // wait a second so as not to send massive amounts of data
}
l’affichage lcd me montre que deja le compteur marche
maintenant je dois faire une etape qui le demarre, et une autre qui le reinitialise
ensuite, je vais essayer de faire mes 3 etapes
là, ou je sais pas trop comment m y prendre c esr faire un tableau à 10 lignes par exemple
qui va divisé la vmax en 10 lignes et sur la deuxieme colonne ca sera le temps
La notion d'interruption est assez importante dans ce que tu veux faire, je te conseille vivement de la comprendre!
En gros, ça permet de faire du multitache, et ce n'est pas bloquant (tant qu'on ne s'amuse pas à mettre un delay dans une ISR 
)
Une fois qu'on en a compris le principe, et qu'on a vu la cinquantaine d'INT dispos dans un AVR, le monde de la précision s'ouvre à nous!
salut, oui je sais bien qu’il ne faut surtout pas de pause
dans mes programmes habituel (plus simple a coder, j utilise des module g1/g2/g3 que je fais varier par etape
ce qui fait que une machine complexe avec 6 modules, autour d’une table a index, j arrive a gerer tout les capteurs de position en meme temps.
mais j avoue ne pas etre familier avec l arduino, comme je suis qqun de tres multitache,j’ai un peu de mal si c est trop complexe pour faire une tache simple
bon revenons en au chmilblik
la j ai tenter un truc mais je bloque
j ai declarer ma pin 11, comme une sortie
voici le code que j utilise (il y a certainement des truc qui serve a rien, j ai piquer ça dans un programme a moi
#include <LiquidCrystal.h>
unsigned long time;#define PULSE 11
// Variables pour utiliser l’écran
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // Définir les pins utilisées par le LCDvoid setup(){
pinMode(11, OUTPUT);
lcd.setCursor(0,0);
lcd.print(" “);
lcd.setCursor(0,1);
lcd.print(” ");Serial.begin(9600);
}
void loop(){
Serial.print("Time: ");
time = micros();lcd.setCursor(0,0);
lcd.print(micros());
lcd.setCursor(0,1);
lcd.print(" ");if ((micros()/1000)>2000)
{analogWrite(11,micros()/1000000);}Serial.println(time); //prints time since program started
//delay(1000); // wait a second so as not to send massive amounts of data
}
dans la fonction analogwrite(11,xxxx), j’arrive pas a faire varier la vitesse du moteur
Ton analogWrite(11,xxx) produit une PWM de l'ordre de 490Hz, dont le rapport cyclique dépend du nombre de secondes écoulées depuis le dernier reset. Mais le 490Hz ne bouge pas, donc le moteur tourne à 490 pas par seconde.
il faut faire varier la fréquence de ta pwm pour faire varier la vitesse du moteur. C'est là qu'il faut entrer dans le gras, ce que nous, les initiés, appelons les registres. Il faut alors se procurer la datasheet du ATMEGA328 : la bible ultime de l'arduiniste, 566 pages de masturbation hard (en anglais), le bonheur!
Le site ATMEL (fabricant du µP qui équipe arduino) n'est pas non plus avare de notes techniques d'applications et je suis sûr qu'il y en a une qui traite des moteurs pas à pas. Leurs codes fonctionnent sur arduino, ouf!
oui mon pote me l a expiquer tout a l heure
l autre jour on a reussi a faire varier la vitesse, je vais revoir ca
Je viens de relire l'ensemble de ce sujet. En fait, et je n'en avais pas pris conscience, vous utilisez un "driver" qui pilote votre moteur pas à pas à l'aide de 2 signaux :
- un pour le sens
- un pour la commande des pas : une impulsion : un pas.
Il est évident que dans ce cas, vous ne pouvez pas utiliser la bibliothèque "accelStepper" qui, elle, fournit les signaux pour chaque bobinage du moteur pas à pas.
Encore qu'en farfouillant bien, je pense qu'on doit pouvoir s'en servir.
Donc, si vous ne vous en servez pas, c'est à vous de fabriquer des séquences d'impulsions dont la fréquence sera représentative de la vitesse à commander Ce sera à vous de programmer les séquences d'accélération/décélération.
Dans votre réponse n° 11 vous écrivez :
sur les autres automates que je code, j ai beaucoup moins mal à la tête
j'écris
moveaxe 1(numero de l axe),100(accel),10000(vitesse),200(deccell),3000(nombre de pas)
Vous avez peut-être la bibliothèque ce cet autre automate, si oui, analysez-là, sinon, c'est à vous de programmer cette fameuse fonction "moveaxe()".
Pour ce faire, ill serait intéressant de connaître la largeur (min à max) de l'impulsion nécessaire au "driver" qui pilote de votre moteur. Si ces impulsions sont fines, quelques micro-secondes, il peut être envisageable de piloter plusieurs moteurs sans avoir recours aux interruptions, mais juste un séquenceur.
Cordialement.
Pierre