Problème moteur pas à pas

Bonjour à tous!

Je travail actuellement sur un projet perso et voici mon problème :

Je fais fonctionner deux moteur pas à pas avec ma carte arduino mega , mais lorsque un moteur reçoit l'ordre de fonctionner et bien le programme attend qu'il est fini l’opération pour exécuter la suite du programme , du coup un seul moteur peut travailler à la fois et les info en temps réel sur l'afficheur sont figé (température et débit) :roll_eyes: .

Je souhaiterai obtenir un systeme réactif pour que les deux moteur puisse travailler en meme temps et que l'affichage ne soit pas figé si vous avez des idées je suis preneur Merci d'avance XD

Salut, alors pour ton problème, je pense que la solution c'est de ne plus utiliser les instructions du style go_position, qui ne te rende la main qu'une fois la position atteinte mais plutôt de travailler avec des instructions du style faire un pas dans la direction souhaité, deuxième moteur faire un pas dans la directions souhaité , actualiser les infos et les afficher sur l’écran, puis rebelote jusqu'à la position souhaité sur les deux moteurs, comme sa tu aura un traitement "simultané" des taches, tu perdra surement un peut en rapidité d’exécution etc mais au moins tu ne fera plus qu'une seul tache à la fois ( même si dans le fond tu fait du mono tache ) .

Après tu ne nous à pas dit quel lib tu utilise et donc je ne peut te dire quel instruction utiliser pour réaliser ceci mais je pense que tu va trouver.

GL.

Skizo.

Tu es typiquement dans la problématique de tous les firmwares pour pilotage de CNC (ou autre système à moteur PAP) : le temps réel.

Sur GRBL (le firmware pour CNC le plus connu), ils utilisent les timers directement. De ton côté si tu veux commencer simple deux options :

  • en gardant un pilotage purement Arduino : en utilisant les interruptions temporelles. Exemple :
void loop() {

GestionAffichage();
GestionMoteur();

}

void GestionMoteur() {

if(micros()>=Depart+Delai) FaireUnPas();

}

void FaireUnPas() {

// ici ton code qui pilote le pont le H

Delai=1000; // à toi d'ajuster 
Depart=micros();

}

Bien sûr c'est un code très sommaire mais je pense que tu as compris l'idée. Le point important à retenir c'est que GestionAffichage() ne doit pas prendre beaucoup de temps, sinon ça va perturber la vitesse de ton moteur.

En résumé : Un micro-controleur n'est pas multitâche, il est même trop peu puissant pour simuler un pseudo multitâche comme le font les micro-processeurs multi cœurs à 3 GHz d'horloge. Il met toutes ses taches en série, sachant qu'une opération élémentaire prend le plus souvent plusieurs cycles d'horloge. Une page utile : http://www.nongnu.org/avr-libc/user-manual/benchmarks.html

L'électronique peut se paralléliser, voir l'exemple de @Batto avec le TMC222. Il te reste à trouver le bon compromis entre un logiciel bien adapté, avec des séquences d'instructions courtes et de l'électronique qui vivra sa vie.

Les Timers sont un cas particulier : ce sont des compteurs électroniques qui vivent leur vie a l'intérieur de la puce micro-controleur. Le logiciel n'a rien d'autre à faire que de les configurer, de les lancer et éventuellement les arrêter. Les timers se chargent tous seul de déclencher des interruptions.

bonsoir

@68tjs et ça c'est quoi ?

Caractéristiques : • Code de produit : P8X32A-D40 • Processeurs (Cogs) : huit • Architecture : 32-bits • Vitesse de l'horloge : cc à 80 MHz • RAM/ROM : 64 K octets ; 32 K RAM / 32 K ROM • Cog RAM : 512 x 32 bits chacune • Broches d'E/S : 32 (attribuables simultanément par les huit cogs) • Courant de source/absorbé par E/S : 40 mA • Modes de l'horloge : (a) Cristal externe 4-8 MHz (16 x PLL) (b) Oscillateur interne ~12 MHz ou ~20 kHz (c) Entraînement direct • Type de boîtier : DIP à 40 broches

;)

C'est ce qu'on trouve maintenant dans les UNO R*4* et Mega R*4* -> Super :grin:

Salut,

chabot380: @68tjs et ça c'est quoi ?

Caractéristiques : • Code de produit : P8X32A-D40 • Processeurs (Cogs) : huit • Architecture : 32-bits • Vitesse de l'horloge : cc à 80 MHz • RAM/ROM : 64 K octets ; 32 K RAM / 32 K ROM • Cog RAM : 512 x 32 bits chacune • Broches d'E/S : 32 (attribuables simultanément par les huit cogs) • Courant de source/absorbé par E/S : 40 mA • Modes de l'horloge : (a) Cristal externe 4-8 MHz (16 x PLL) (b) Oscillateur interne ~12 MHz ou ~20 kHz (c) Entraînement direct • Type de boîtier : DIP à 40 broches

;)

C'est de la triche ;) C'est des processeurs 32 bits multi-core avec un "hub tournant" pour l'accès aux ressources partagées.

Je me suis fait une carte de dév l'année dernière mais le code en langage mi-basic mi-assembleur c'est franchement pas génial. Et le compilo dérivé de GCC donne des résultats plus que moyen, les 32K de programme sont vite remplis.

Le nouveau processeurs Propeller 2 par contre ça va être une véritable tuerie d'aprés les spec ;) http://www.parallaxsemiconductor.com/Products/propeller2specs

Bonsoir et merci pour vos réponses, je suis désolé de répondre seulement maintenant car j’étais à l'étranger en déplacement . Pour revenir au sujet j'ai beau me casser la tete à écrire un code qui me convienne mais rien a faire Si par exemple:

if (temp>tempset)

mot1  + 20;
mot2 - 20;

....

Dans tout les cas il exécute en premier l’électrovanne 1 :( y aurait il pas une solution qui par exemple lance le moteur 1 à faire 20 pas puis qui n'attend pas qu'il ai fini pour lancer le moteur 2 à en faire -20 pas ,en gros qui donne simplement l'ordre sans attendre qu'il ai fini

pour ce qui est du contrôleur TMC222 comment je peux faire car j'ai déjà deux contrôleur pour mes moteurs et je pense pas qu'il supporte 2 A sans faire fondre les support :/

Youhou:
Dans tout les cas il exécute en premier l’électrovanne 1 :frowning: y aurait il pas une solution qui par exemple lance le moteur 1 à faire 20 pas puis qui n’attend pas qu’il ai fini pour lancer le moteur 2 à en faire -20 pas ,en gros qui donne simplement l’ordre sans attendre qu’il ai fini

Au lieu de faire ça

if (temp>tempset)

mot1  + 20;
mot2 - 20;

....

on t’a proposé de faire ça

if (temp>tempset)
for (x=0;x<20;x++){
mot1  + 1;
mot2 - 1;
}
....

Ce qui fonctionnellement correspond à la même chose avancer de 20 pas les 2 moteurs. Mais de ce cas on a les 2 moteurs qui avancent de concert.

Je vais peut être défoncer une porte ouverte mais deux assertions me semblent importantes à prendre en compte :

  • L’avantage d’un moteur pas à pas c’est de pouvoir savoir “où il est” sans pour autant intercaler un capteur de position. Il suffit après une initialisation de base de compter et décompter les pas effectés.
  • L’affirmation ci-avant n’est valique que si nous avons la certitude que le moteur aura bien effectué son monvement donc :
  • Son couble disponible doit dépasser le couple résistant.
  • Il faut impérativement une temporisation entre deux commandes.
    Du coup ton processeur a largement le temps de tout faire.
    Une boucle de base du genre doit te permettre de piloter “simultanément” tes divers moteurs :

Moteur 1 arrivé en position ? Si oui passer au suivant/si NON donner la consigne pour unpas de plus.
Moteur 2 arrivé en position ? Si oui passer au suivant/si NON donner la consigne pour unpas de plus.
Moteur N rrivé en position ? Si oui passer au suivant/si NON donner la consigne pour unpas de plus.
Temporisation pour un pas si au moins un moteur tourne.
Passer à la suite dans ta boucle de base.

La seule pénalité c’est que la boucle de base est ralentie quand au moins un moteur tourne, mais en général la tempo pour un pas est inférieure à 0,1seconde.
Amicalement : Nulentout.

Bonjour et merci pour ta réponse rapide! Je comprends ton raisonnement mais le truc c'est que la vitesse du moteur doit être pris en compte car si il tourne vite ta solution est bonne mais si il doit tourner lentement ce qui est son cas (car c'est une electrovanne) elle ne peut donc s'ouvrir vite car il y a la pression de l'eau qui est exercé sur le vanne . Donc si elle tourne lentement et si en plus je temporise à la fin de l'instruction alors la il y aura un trop grand ralentissement général

Voici les caractéristiques de l'électrovanne:

  • Type d‘actionneur : moteur pas à pas unipolaire
  • Tensions nominales du moteur : 18 V DC

  • Puissance nominale : 6 W

  • Nombre de phases : 6

Sachant qu'il y a deux électrovannes je pense que la solution a mon problème est un driver performant mais la je ne sais pas lequel si vous avez des drivers à me conseiller je suis preneur

Ralentir un moteur est enfantin, c'est toujours plus simple que de chercher à aller rapidement. Voici une solution simple. Dans ta boucle de base à chaque passage tu incrémentes un compteur. Tu n'envoie une instruction à ton moteur que lorsque le compteur est arrivé à une valeur donnée. Ainsi tu peux établir une temporisation qui ne ralentit pas ta boucle de base. Quand tu envoie ton ordre de faire un nouveau pas à ton moteur, tu replaces le compteur à zéro. Naturellement si tu veux gérer plusieurs moteurs, tu affecte un compteur par moteur. Par exemple, le petit programme que j'ai réalisé pour automatiser la barre d'un "petit navire" fait clignoter une LED dans la boucle de base. C'est pour moi le témoin que la boucle tourne et qu'elle n'est pas "plantée" dans une procédure quelconque. Donc cette LED clignote en permanence. Tu te doutes bien que je ne procède pas par des "delay". J'ai un compteur dont j'ai choisi la valeur maximale expérimentalement en fonction de la rapidité de la boucle de base. Comme la boucle de base n'est qu'une suite d'appels à procédure, voici le code pour faire clignoter ma LED :

void FaireClignoterLED13() {Chrono_LED = Chrono_LED + 1;
  if (Chrono_LED == 30) {
     if (Active) {digitalWrite(LED_Arduino, LOW);}
            else {digitalWrite(LED_Arduino, HIGH);}
     Active = !Active; Chrono_LED = 0; } }

Tu vois que la procédure par elle même est extrêmement rapidement exécutée, il y a peu d'instructions et elle ne pénalise pas la boucle principale. La valeur de 30 peut sembler faible pour générer une temporisation d'une demi-seconde environ, mais la boucle de base effectue un gros travail, donc elle ne "tourne pas comme une folle". :) Amicalement : Nulentout.