Menu de contrôle de vitesse pas à pas piloté pour Arduino : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Cette bibliothèque SpeedStepper est une réécriture de la bibliothèque AccelStepper pour permettre le contrôle de la vitesse du moteur pas à pas. La bibliothèque SpeedStepper vous permet de modifier la vitesse du moteur définie, puis d'accélérer/décélérer jusqu'à la nouvelle vitesse définie en utilisant le même algorithme que la bibliothèque AccelStepper. La bibliothèque SpeedStepper vous permet également de définir des limites plus et moins et une position « origine ». Il existe une commande goHome pour revenir à la position initiale.

Limitations: La bibliothèque SpeedStepper ne pilote que les sorties directionnelles et pas à pas et doit donc être connectée à un pilote de moteur, tel qu'Easy Driver, pour piloter réellement le moteur pas à pas. La bibliothèque AccelStepper fournit plus d'options de pilotage qui peuvent être copiées dans cette bibliothèque si nécessaire.

Trois exemples de croquis sont fournis, chacun pouvant être exécuté sans moteur ni pilote de moteur. speedStepperPlot sketch émet des exemples de commandes de vitesse et la commande goHome et génère un tracé de la vitesse et de la position résultantes. L'esquisse speedStepperSetup fournit une configuration pilotée par menu pour définir la maison et les limites du moteur, puis faire fonctionner le moteur et ajuster la vitesse vers le haut et vers le bas et goHome pour terminer. L'esquisse speedStepperProfile montre un exemple de configuration et d'exécution d'un profil de vitesse.

Alors que la bibliothèque AccelStepper fournit un bon contrôle de position, un contrôle de vitesse était nécessaire pour le prototype de sonde de fonte des glaces pour la collecte d'échantillons biologiques sur Europa. Voici une vidéo d'une version antérieure du prototype, qui utilisait du poids au lieu d'un moteur. La révision 1.1 a ajouté des profils de vitesse après qu'un utilisateur a demandé un moyen de contrôler le profil de vitesse d'une pompe.

Cette bibliothèque fonctionne sur Arduino Uno et Mega2560, mais pour le prototype, une mémoire plus grande / un processeur plus rapide SparkFun Redboard Turbo a été utilisé.

Cette instructable est également disponible en ligne à Stepper Speed Control Library pour Arduino

Fournitures

Pour exécuter les exemples de croquis, seul un Arduino UNO ou Mega2560 et les bibliothèques logicielles sont nécessaires

Pour les tests au banc de la bibliothèque, un SparkFun Redboard Turbo a été utilisé avec un Easy Driver, un moteur pas à pas 200 pas/tour, 12V 350mA et une alimentation 12 DC 2A ou plus, par ex. https://www.sparkfun.com/products/14934. Câble USB A vers MicroCâble série USB vers TTLArduino IDE V1.8.9 et un ordinateur pour l'exécuter. Bibliothèque SpeedStepper bibliothèque pfodParser pour les classes nonBlockingInput et pfodBufferedStream bibliothèque millisDelay pour les retards non bloquants

Étape 1: Fonctions de la bibliothèque

La bibliothèque SpeedStepper exécute le moteur pas à pas limité par les limites définies par la bibliothèque. Voir le fichier SpeedStepper.h pour les différentes méthodes de bibliothèque disponibles. Voici un aperçu de la logique qui les sous-tend.

La position du stepper est suivie en comptant le nombre de pas (impulsions). La bibliothèque limite la position entre les positions setPlusLimit(int32_t) et setMinusLimit(int32_t). La limite plus est toujours >= 0 et la limite moins est toujours <= 0. Au démarrage, la position du moteur est 0 (home) et les limites sont réglées sur des nombres +/- très grands (environ +/-1e9 pas). setAcceleration(float) définit à quelle vitesse le moteur changera de vitesse vers le haut ou vers le bas. Lorsque le moteur s'approche de la limite plus ou moins, il décélère à ce rythme jusqu'à ce qu'il s'arrête à la limite. Au démarrage, l'accélération est réglée sur 1,0 pas/sec/sec. Le paramètre d'accélération est toujours un nombre +ve. Le signe du réglage setSpeed(float) définit la direction dans laquelle le moteur se déplacera.

setSpeed(float) définit la vitesse à laquelle accélérer/décélérer le moteur à partir de sa vitesse actuelle. La vitesse qui peut être définie via setSpeed(float) est limitée, en valeur absolue, par les paramètres setMaxSpeed(float), par défaut 1000 pas/sec et setMinSpeed(float), par défaut 0,003 pas/sec. Ces valeurs par défaut sont également les limites de vitesse absolues codées en dur que la bibliothèque acceptera pour setMaxSpeed() et setMinSpeed(). Si vous souhaitez définir une vitesse maximale > 1000 pas/sec, vous devrez modifier la première ligne du fichier SpeedStepper.cpp pour modifier la vitesse maxMax (1000) à la vitesse maximale souhaitée. En pratique, la vitesse maximale est également limitée par le temps entre les appels à la méthode run() de la bibliothèque. Pour 1000 pas/sec, la méthode run() doit être appelée au moins toutes les 1mS. Voir la section Latence ci-dessous.

Essayer de régler une vitesse inférieure à la vitesse minimale entraînera l'arrêt du moteur. Chacun de ces setters a un getter correspondant, voir le fichier SpeedStepper.h. Pour la vitesse, getSetSpeed() renvoie la vitesse que vous avez définie via setSpeed(), tandis que getSpeed() renvoie la vitesse actuelle du moteur qui varie à mesure qu'il accélère/décélère jusqu'à la vitesse définie. Si le moteur ne va pas dans la direction que vous pensez d'un +ve, vous pouvez appeler invertDirectionLogic() pour échanger la direction dans laquelle le moteur se déplace pour les vitesses +ve.

getCurrentPosition() renvoie la position actuelle du moteur par rapport à 'home' (0). Vous pouvez remplacer la position actuelle du moteur setCurrentPosition(int32_t). La nouvelle position est limitée aux limites plus/moins définies.

Initialement, le moteur est arrêté à la position 0. L'appel de setSpeed(50.0) le fera commencer à accélérer dans le sens +ve jusqu'à une vitesse maximale de 50 pas/min. L'appel de hardStop() arrêtera immédiatement le moteur là où il se trouve. D'un autre côté, l'appel de la méthode stop() mettra la vitesse à zéro et ralentira le moteur jusqu'à l'arrêt. L'appel de stopAndSetHome() arrêtera le moteur immédiatement et définira sa position sur 0. Les valeurs limites plus/moins ne sont pas modifiées mais sont maintenant référées à cette nouvelle position 0 (origine). L'appel de goHome() ramènera le stepper à cette position 0 (home) et s'arrêtera. L'appel de setSpeed() annulera le retour à la maison.

La bibliothèque SpeedStepper fournit également un contrôle de profil de vitesse via les méthodes setProfile(SpeedProfileStruct* profileArray, size_t arrayLen), startProfile(), stopProfile(), pour interrompre un profil en cours d'exécution, et isProfileRunning(). Voir l'exemple de croquis speedStepperProfile.

Étape 2: Exécution de l'exemple SpeedStepperPlot sans moteur

Installez Arduino IDE V1.8.9Téléchargez et installez la bibliothèque SpeedStepper Enregistrez le SpeedStepper.zip, puis utilisez l'élément de menu Arduino IDE Sketch → Inclure la bibliothèque → Ajouter la bibliothèque. ZIP pour importer la bibliothèque Téléchargez et installez également la bibliothèque millisDelay

Ouvrez l'esquisse d'exemple Exemples → SpeedStepper → speedStepperPlot (Redémarrez l'EDI si nécessaire). Cette esquisse est configurée pour fonctionner avec Serial, par ex. UNO et Mega etc. Pour l'exécution sur le SparkFun Redboard Turbo, voir ci-dessous.

Aucune carte de commande ou moteur pas à pas n'est nécessaire pour exécuter cet exemple. Ces exemples utilisent D6 et D7 comme sorties. Vous pouvez remplacer les broches de sortie par n'importe quelle sortie numérique en modifiant les paramètres STEP_PIN et DIR_PIN près du haut de l'esquisse.

Téléchargez le croquis sur la carte, puis ouvrez Outils → Traceur série à 115 200 bauds pour afficher le tracé de la vitesse (ROUGE) et de la position (BLEU) La limite plus est définie sur 360, ce qui fait que la vitesse passe à zéro à partir d'environ 100 points sur l'axe des x. La limite négative est de -510. La position s'arrête à ~-390 car la vitesse a été demandée à 0,0. Au point 380 sur l'axe des x, la commande goHome est émise, ce qui ramène le moteur pas à pas à la position zéro.

Cette esquisse speedStepperPlot utilise des millisDelays pour basculer entre différentes vitesses et accélérations. Dans de nombreux cas, l'utilisation d'un SpeedStepperProfile, comme dans l'exemple suivant, est plus simple.

Étape 3: Exécution de l'exemple SpeedStepperProfile sans moteur

Ouvrez l'exemple de croquis Exemples → SpeedStepper → speedStepperPlot, ce croquis produit le tracé ci-dessus à l'aide du traceur série Arduino et est un exemple d'exécution d'un profil de vitesse prescrit, par exemple si vous utilisez une pompe.

Les profils de vitesse pas à pas sont constitués d'un tableau de SpeedProfileStruct, qui est défini dans le fichier SpeedStepper.h.

struct SpeedProfileStruct {

vitesse du flotteur; // la vitesse cible à la fin de cette étape deltaTms long non signé; // le temps pour accélérer de la vitesse actuelle (au début de cette étape) à la vitesse cible };

Définissez un tableau de SpeedProfileStruct contenant la vitesse cible pour chaque étape et le temps, deltaTms, en mS, pour atteindre cette vitesse cible à partir de la vitesse cible précédente. Si le deltaTms est nul ou très petit, la vitesse passera immédiatement à la nouvelle vitesse cible. Sinon, l'accélération requise sera calculée. setAcceleration() sera appelé suivi d'un appel à setSpeed() pour la nouvelle vitesse cible. Dans tous les cas, le profil sera limité par les limites de position plus et moins existantes et les réglages de vitesse max/min. Si vous souhaitez maintenir une vitesse, répétez simplement la vitesse précédente avec le temps que vous souhaitez qu'elle soit maintenue. Étant donné que la nouvelle vitesse cible est la même que la vitesse actuelle, l'accélération calculée sera de zéro et aucun changement de vitesse ne se produit.

Ce tableau SpeedProfileStruct a produit le tracé ci-dessus

const SpeedProfileStruct profile = { { 0, 0}, // s'arrête immédiatement s'il n'est pas déjà arrêté { 0, 1000}, // maintient zéro pendant 1 seconde { -50, 0}, // passe à -50 { -200, 2000}, // rampe jusqu'à -200 { -200, 6000}, // maintien à -200 pendant 6 sec { -50, 2000}, // rampe vers -50 { 0, 0}, // // arrêt immédiat { 0, 1500}, // maintenez zéro pendant 1,5 s { 50, 0}, // sautez à 50 { 200, 2000}, // rampez jusqu'à 200 { 200, 6000}, // maintenez 200 pendant 6 s { 50, 2000}, // rampe jusqu'à 50 { 0, 0}, // // arrête immédiatement { 0, 1000} // maintient zéro // pour tracer la sortie }; const size_t PROFILE_LEN = sizeof(profile) / sizeof(SpeedProfileStruct); // calcule la taille du tableau de profils

Le profil est défini en appelant setProfile(SpeedProfileStruct* profileArray, size_t arrayLen) par ex. stepper.setProfile(profil, PROFILE_LEN);

Une fois le profil défini, appelez startProfile() pour commencer à l'exécuter à partir de la vitesse actuelle du moteur (généralement, vous commencerez à partir de l'arrêt). À la fin du profil, le moteur continuera simplement à fonctionner à la dernière vitesse cible. La méthode isProfileRunning() peut être appelée pour voir si le profil est toujours en cours d'exécution. Si vous souhaitez arrêter le profil plus tôt, vous pouvez appeler stopProfile() qui abandonnera le profil et arrêtera le moteur.

Étape 4: Exécution de l'exemple SpeedStepperSetup sans moteur

L'exemple de croquis est conçu pour servir de base à votre propre application de moteur pas à pas. Il fournit une interface pilotée par menu qui vous permet de déplacer le moteur vers sa position d'origine, s'il n'y est pas déjà, puis de réinitialiser éventuellement les limites plus et moins, puis de faire fonctionner le moteur dans cette plage. Le menu 'run' vous permet d'augmenter et de diminuer la vitesse, de geler à la vitesse actuelle, d'arrêter et également de revenir à la maison.

Ce croquis illustre un certain nombre de fonctionnalités logicielles qui maintiennent la boucle () réactive afin que vous puissiez ajouter vos propres entrées de capteur pour contrôler le stepper. Il prend soin d'éviter les retards qui interféreraient avec le contrôle de la vitesse. (Voir les retards sont mauvais)

Installez les bibliothèques utilisées pour exécuter le SpeedStepperPlot, ci-dessus, puis installez également la bibliothèque pfodParser. La bibliothèque pfodParser fournit les classes NonBlockingInput et pfodBufferedStream qui sont utilisées pour gérer l'entrée utilisateur et la sortie du menu en bloquant l'exécution de loop().

Ouvrez l'exemple Exemples → SpeedStepper → speedSpeedSetup. Cette esquisse est configurée pour fonctionner avec Serial, par ex. UNO et Mega etc. Pour l'exécution sur le SparkFun Redboard Turbo, voir ci-dessous.

Aucune carte de commande ou moteur pas à pas n'est nécessaire pour exécuter cet exemple. Ces exemples utilisent D6 et D7 comme sorties. Vous pouvez remplacer les broches de sortie par n'importe quelle sortie numérique en modifiant les paramètres STEP_PIN et DIR_PIN près du haut de l'esquisse. Téléchargez le croquis sur la carte, puis ouvrez Outils → Moniteur série à 115200 pour voir le menu SETUP.

SETUP pos:0 sp:0.00 +Lim:500000 -Lim:-500 LATENCY: stepper:492uS loop:0uS p -- set Home l -- set limit h -- goHome r -- run >

Lorsque l'esquisse s'exécute, la position actuelle du moteur pas à pas est considérée comme sa position « origine » (0). Si vous devez repositionner le stepper à sa véritable position d'origine, entrez la commande p pour afficher le menu SET HOME

SET HOME pos:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:752uS loop:3852uS x -- setHome here and exit + -- Forward - -- Reverse s -- swap Forward/Reverse -- hardStop >

Comme vous pouvez le voir, les limites codées dans le croquis ont été supprimées afin que vous puissiez repositionner le stepper n'importe où. Vous devez faire attention à ne pas dépasser les limites physiques ou vous pourriez casser quelque chose.

Utilisez le + cmd pour commencer à déplacer le stepper vers l'avant, si vous le trouvez se déplaçant dans la mauvaise direction, entrez une non-commande ou juste une ligne vide pour l'arrêter, puis utilisez la commande scommand pour échanger la direction de Forward. Vous devez mettre à jour l'esquisse pour inclure un appel à invertDirectionLogic() dans la configuration pour résoudre ce problème pour la prochaine exécution.

Utilisez les + / - cmds pour positionner le moteur pas à pas à la bonne position zéro. Le moteur démarre lentement puis augmente sa vitesse au fur et à mesure, utilisez simplement une ligne vide pour l'arrêter. La vitesse maximale pour cela et le menu des limites est définie par MAX_SETUP_SPEED en haut de setupMenus.cpp.

Une fois que le moteur a été positionné à sa position « home », utilisez la commande x pour réinitialiser la position actuelle à 0 et revenir au menu SETUP.

Si vous devez définir les limites, généralement uniquement lors de la configuration initiale, utilisez la commande l pour accéder au menu SET LIMITS

SET LIMITS pos:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:944uS loop:5796uS l -- setLimit here + -- Forward - -- Reverse h -- goHome x -- exit -- hardStop >

Utilisez le + cmd pour avancer vers la limite plus, puis utilisez le l cmd pour le définir comme limite plus. La commande h peut alors être utilisée pour revenir à 0 et le – cmd pour se déplacer s'il revient à la position du moteur à la limite négative. Utilisez à nouveau le cmd l pour définir la limite négative. Notez les positions des limites plus et moins et mettez à jour les instructions setPlusLimit et setMinusLimit de la méthode setup() avec ces valeurs.

Lorsque les limites sont définies, utilisez la cmd x pour revenir au menu SETUP, puis vous pouvez utiliser la cmd r pour ouvrir le menu RUN

RUN MENU pos:0 sp:3.31 +Lim:500000 -Lim:-500 LATENCY: stepper:944uS loop:5796uS + -- Speed up - -- Speed down h -- goHome. -- hardStop -- freeze Speed >+ pos:4 sp:9.49 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS pos:42 sp:29.15 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS pos:120 sp:49.09 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS pos:238 sp:69.06 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop: 5664uS

La commande + commence à accélérer en marche avant et imprime la position et la vitesse toutes les 2 secondes. Lorsque le moteur atteint la vitesse souhaitée, vous pouvez arrêter l'accélération avec n'importe quelle autre touche (ou une entrée vide). Vous pouvez réduire la vitesse en utilisant le - cmd bas pour arrêter. S'il est arrêté, le – cmd accélérera en sens inverse.

Ce menu RUN permet de contrôler manuellement votre projet. Pour le contrôle automatique, vous devrez ajouter d'autres capteurs.

Étape 5: Latence

La commande du moteur pas à pas dépend du logiciel commandant chaque étape. Pour maintenir la vitesse définie, votre esquisse doit appeler la méthode stepper.run() assez souvent pour déclencher l'étape suivante au bon moment pour la vitesse actuelle. Pour le contrôle via des capteurs, vous devez être en mesure de traiter rapidement de nouvelles mesures. L'impression position/vitesse comprend deux mesures de LATENCE pour vous permettre de vérifier que votre croquis est suffisamment rapide.

Latence pas à pas (pfodBufferedStream)

La latence du stepper mesure le délai maximum entre les appels successifs à la méthode stepper.run(). Afin de faire fonctionner le moteur pas à pas à 1000 pas par seconde, la latence du pas à pas doit être inférieure à 1000uS (1mS). La première version de ce sketch avait une latence de plusieurs millisecondes. Pour surmonter cela, des appels supplémentaires à la méthode runStepper() (qui appelle stepper.run()) ont été ajoutés via le code. Cela n'a pas complètement résolu le problème car le menu et les instructions d'impression de sortie bloquaient l'esquisse une fois que le petit tampon Serial Tx était plein. Pour éviter ce blocage, pfodBufferedStream de la bibliothèque pfodParser a été utilisé pour ajouter un tampon d'impression de sortie de 360 octets dans lequel les instructions d'impression pouvaient rapidement écrire. Ensuite, pfodBufferedStream libère les octets à la vitesse de transmission spécifiée 115200 dans ce cas. pfodBufferedStream doit choisir de bloquer lorsque le tampon est plein ou simplement de supprimer les caractères de débordement. Ici, il est configuré pour supprimer tous les caractères supplémentaires lorsque le tampon est plein afin que l'esquisse ne soit pas bloquée en attendant que Serial envoie des caractères.

Latence de boucle (entrée non bloquante)

La latence de boucle mesure le délai maximum entre les appels successifs à la méthode loop(). Cela définit la vitesse à laquelle vous pouvez traiter les nouvelles mesures du capteur et ajuster la vitesse définie du moteur. La vitesse à laquelle il faut alors dépend de ce que vous essayez de contrôler.

Les retards dus aux instructions d'impression ont été supprimés en utilisant pfodBufferedStream ci-dessus, mais pour traiter l'entrée de l'utilisateur, vous devez prendre le premier caractère de l'entrée et ignorer le reste de la ligne. La classe NonBlockingInput dans la bibliothèque pfodParer est utilisée pour renvoyer un caractère différent de zéro lorsqu'il y a une entrée, en utilisant readInput(), et pour effacer et supprimer les caractères suivants, en utilisant clearInput(), jusqu'à ce qu'aucun caractère ne soit reçu pendant 10mS sans bloquer la boucle ()

Bien sûr, la latence de la boucle sera augmentée par le code supplémentaire que vous ajoutez pour lire les capteurs et calculer la nouvelle vitesse définie. De nombreuses bibliothèques de capteurs utilisent simplement le délai (..) entre le démarrage d'une mesure et la récupération du résultat. Vous devrez réécrire ces bibliothèques pour utiliser à la place millisDelay, pour récupérer la mesure après un délai non bloquant approprié.

Étape 6: Exécuter SpeedStepperSetup avec un moteur pas à pas et SparkFun Redboard Turbo

Pour exécuter le sketch SpeedStepperSetup pour de vrai, vous aurez besoin d'un moteur pas à pas, d'un pilote et d'une alimentation et dans cet exemple SparkFun Redboard Turbo.

Le schéma de câblage ci-dessus (version pdf) montre les connexions. Dans l'esquisse SpeedStepperSetup, remplacez la définition SERIAL par #define SERIAL Serial1

Moteur pas à pas, alimentation, pilote et protection

Il existe de nombreux types et tailles de moteurs pas à pas. Ici, un moteur pas à pas à deux bobines 12V 350mA est utilisé pour les tests. Pour alimenter ce stepper vous avez besoin d'une alimentation de 12V ou plus et supérieure à 350mA.

Cette bibliothèque ne fournit qu'une sortie de direction et de pas, vous avez donc besoin d'un pilote pour s'interfacer avec le moteur pas à pas. L'Easy Driver et le Big Easy Driver contrôlent le courant vers les bobines du moteur afin que vous puissiez utiliser une alimentation d'une tension plus élevée en toute sécurité, par exemple en utilisant une alimentation 6V pour un moteur 3,3V. L'Easy Driver peut fournir entre 150mA/bobine et 700mA/bobine. Pour des courants plus élevés, le Big Easy Driver peut fournir jusqu'à 2A par bobine. Lisez la FAQ au bas de la page Easy Drive.

Ces exemples utilisent D6 et D7 comme sorties Pas et Direction. Vous pouvez remplacer les broches de sortie par n'importe quelle sortie numérique en modifiant les paramètres STEP_PIN et DIR_PIN près du haut de l'esquisse.

Programmation du Sparkfun Redboard Turbo

La programmation du Redboard Turbo est problématique. S'il ne parvient pas à programmer, appuyez d'abord sur le bouton-poussoir de réinitialisation et resélectionnez le port COM dans le menu Outils Arduino et réessayez. Si cela ne fonctionne pas, appuyez deux fois sur le bouton de réinitialisation et réessayez.

Câblage de l'Easy Driver

Les moteurs pas à pas à deux bobines ont 4 fils. Utilisez un multimètre pour trouver les paires qui se connectent à chaque bobine, puis câblez une bobine aux bornes Easy Driver A et l'autre bobine à la borne B. Peu importe dans quel sens vous les câblez car vous pouvez utiliser la commande s dans le menu de configuration pour changer le sens du mouvement.

L'alimentation du moteur est câblée sur le M+ et GND Réglez le niveau logique de la carte avec la liaison 3/5V. Court-circuitez le lien pour les sorties du microprocesseur 3,3 V, comme le SparkFun Redboard Turbo (si vous le laissez ouvert, il convient aux signaux numériques 5 V, par exemple UNO, Mega) Connectez les broches GND, STEP, DIR au microprocesseur GND et au step et broches de sortie dir. Aucune autre connexion n'est nécessaire pour entraîner le moteur.

Câble série USB vers TTL

Lorsque vous déplacez l'esquisse SpeedStepperSetup de l'Uno/Mega vers le Redboard Turbo, vous pouvez simplement remplacer naïvement #define SERIAL Serial par #define SERIAL SerialUSB pour s'adapter à la connexion série USB Redboard Turbo, mais vous constaterez que la latence du stepper résultante est d'environ 10 mS. C'est 10 fois plus lent que pour l'ONU. Cela est dû à la façon dont le processeur Redboard gère la connexion USB. Pour surmonter cela, connectez un câble série USB vers TTL à D0/D1 et définissez #define SERIAL Serial1 pour utiliser la connexion série matérielle pour contrôler le moteur pas à pas. L'utilisation de Serial1 donne LATENCY: stepper:345uS loop:2016uS qui est 3 fois plus rapide que l'UNO pour le stepper et la latence de la boucle

Programme terminal

Le moniteur série Arduino est un peu plus difficile à utiliser pour contrôler le moteur pas à pas car vous devez entrer le caractère dans la ligne cmd, puis appuyer sur Entrée pour l'envoyer. Un moyen plus rapide et plus réactif consiste à ouvrir une fenêtre de terminal, TeraTerm pour PC (ou CoolTerm Mac), connectée au port COM du câble USB vers TTL. Ensuite, dans cette fenêtre, appuyez sur une touche cmd pour l'envoyer immédiatement. En appuyant sur Entrée, envoyez simplement une ligne vide.

Réglage de la plage de vitesse du moteur

Comme câblé ci-dessus, l'Easy Drive est configuré pour des pas de 1/8e, donc 1000 pas/sec feront tourner le moteur à 1000/8/200 pas/tour = 0,625 tr/min ou 37,5 tr/min maximum. En changeant les entrées en MS1/MS2, vous pouvez basculer entre 1/8, ¼, ½ et des pas complets. Pour les étapes complètes, connectez MS1 et MS2 à GND. Cela permettra des vitesses allant jusqu'à 300 tr/min. Le choix des paramètres MS1/MS2 appropriés vous permet d'ajuster le rapport de démultiplication installé entre le moteur et la partie entraînée.

Protection du matériel

Alors que la bibliothèque SpeedStepper vous permet de définir des limites de position sur le mouvement du moteur, le pointage de la position se fait en comptant les pas émis par le logiciel. Si le moteur cale, c'est-à-dire que le couple est insuffisant pour entraîner le moteur à l'étape suivante, la position du logiciel sera désynchronisée avec la position du moteur. Ensuite, lorsque vous utilisez la commande 'goHome', le moteur dépassera la position d'origine. Pour éviter d'endommager le matériel, vous devez installer des interrupteurs de fin de course aux limites dures pour déconnecter l'alimentation du moteur

Réglage de la limite de courant du moteur

Tout d'abord, réglez-le sur le réglage le plus bas du potentiomètre. c'est-à-dire que la tension à TP1 est minimale. Le potentiomètre est délicat, alors ne forcez pas le potentiomètre au-delà des butées mécaniques. Réglez le moteur à une vitesse lente et constante, puis tournez lentement le potentiomètre jusqu'à ce que le moteur ne saute pas ou ne saute pas entre les étapes.

Conclusion

Ce projet montre comment utiliser la bibliothèque SpeedStepper dans une application pratique. Alors que la bibliothèque AccelStepper fournit un bon contrôle de position, le contrôle de la vitesse était nécessaire pour la sonde prototype de fonte des glaces pour la collecte d'échantillons biologiques sur Europa. La bibliothèque AccelStepper a donc été réécrite pour fournir un contrôle de vitesse avec des limites de fin et une fonction goHome.