deplacement moteur pas a pas avec rampe accel decell

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

http://fdec.fr/motpap/

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

Avez-vous regardé les possibilités offertes par cette bibliothèque ?

Cordialement.

Pierre

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 5

void 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 :slight_smile: )

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 LCD

void 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