Conduire un moteur pas à pas avec un microprocesseur AVR : 8 étapes

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

Vous avez des moteurs pas à pas récupérés des imprimantes/lecteurs de disque/etc qui traînent ?

Quelques sondages avec un ohmmètre, suivis d'un simple code de pilote sur votre microprocesseur et vous avancerez avec style.

Étape 1: Apprenez à connaître les steppers

Fondamentalement, vous allez devoir trouver où vont tous les petits fils.

La première étape consiste à déterminer s'il s'agit d'un moteur unipolaire ou bipolaire. Jetez un œil à Jones on Steppers pour des informations plus approfondies, puis au site de Ian Harries pour une méthode simple pour découvrir un moteur inconnu. Lisez un peu, puis rejoignez-moi dans une présentation de ce moteur que j'ai eu pour pas cher. (Ils sont en vente pour 0,99 $ en ce moment. Ils sont petits, relativement légers, mais n'ont pas beaucoup de couple. Je ne sais pas encore à quoi ça va servir.)

Étape 2: Trouver un terrain d'entente

Vous avez donc cinq (ou quatre, ou six) fils. Votre moteur va avoir deux moitiés, et vous pouvez probablement même dire simplement en regardant de quel côté appartient chaque fil.

Si vous ne regardez que quatre fils, vous avez de la chance - c'est un moteur bipolaire. Tout ce que vous avez à faire est de déterminer quelles paires de fils vont ensemble. Si vous avez un moteur unipolaire, ou plus de 4 fils, vous allez devoir casser votre ohmmètre. Ce que vous recherchez, c'est le fil commun (masse) pour chaque moitié. Vous pouvez dire ce qui est mis à la terre dans un moteur bipolaire car il a la moitié de la résistance à l'un des pôles que les pôles entre eux. Sur la photo, mes notes de branchement de fils aux fils et de notation de la résistance (ou s'ils sont connectés du tout). Vous pouvez voir que le blanc est le terrain pour le trio du bas car il a la moitié de la résistance au rouge ou au bleu qu'ils ont les uns envers les autres. (Ce moteur est étrange et n'a pas de prise centrale sur la bobine magnétique supérieure. C'est comme s'il était à moitié bipolaire, à moitié unipolaire. Vous pourriez peut-être l'utiliser pour détecter la rotation dans la bobine rouge-blanc-bleu lorsque le noir-jaune la bobine est entraînée.)

Étape 3: Déterminez l'ordre de progression

J'allais conduire ce moteur comme un moteur bipolaire, donc j'ignore le fil de terre blanc. Je n'ai que quatre fils à craindre.

Vous voudrez peut-être faire fonctionner votre moteur unipolaire comme bipolaire de toute façon, car il utilise toute la bobine dans les deux phases au lieu d'alterner entre les deux moitiés de chaque bobine. Plus de bobine = plus de couple. Faites passer le courant à travers une paire (en notant la polarité que vous avez choisie), puis faites passer le courant à travers l'autre paire en même temps. Lorsque vous branchez la deuxième paire, regardez dans quel sens tourne le moteur. Notez ceci. Inversez maintenant la polarité sur la première paire que vous avez choisie. Branchez ensuite à nouveau la deuxième paire avec leur polarité également inversée. Notez la direction. À partir de là, vous devriez être en mesure de déterminer la séquence de rotation du moteur dans les deux sens. Dans mon exemple, les deux ont fini par tourner dans le sens inverse des aiguilles d'une montre, donc parcourir la séquence de la même manière que j'ai choisi fera avancer le moteur dans le sens inverse des aiguilles d'une montre.

Étape 4: Prendre le moteur pour un essai routier

Si vous n'êtes pas déjà outillé pour la programmation de microprocesseurs, vous pourriez faire pire que le Ghetto Development Kit ou l'un des divers programmeurs PIC. Branchez les fils directement sur votre microproc et gravez-le avec le code suivant:

/* Jouer avec l'entraînement des petits moteurs pas à pas. */

/* Inclure la fonction de délai */ #define F_CPU 1000000UL #include /* Définitions des broches pour ATTiny2313 */ /* Ordre dans le sens horaire */ #define BLUE _BV(PB0) #define BLACK _BV(PB1) #define RED _BV(PB2) #define JAUNE _BV(PB3) #define DELAY 200 /* millisecondes entre les étapes */ int main(void){ DDRB = 0xff; /* Activer la sortie sur toutes les broches B */ PORTB = 0x00; /* Mettez-les tous à 0v */ while(1){ /* boucle principale ici */ PORTB = BLUE; _delay_ms(DELAY); PORTB = NOIR; _delay_ms(DELAY); PORTB = ROUGE; _delay_ms(DELAY); PORTB = JAUNE; _delay_ms(DELAY); } } À quel point ce code est-il simple ? Vraiment simple. Tout ce qu'il fait, c'est faire de belles définitions pour que je puisse faire référence aux fils par couleur plutôt qu'à leurs noms de broche, puis il les active en séquence avec un délai réglable entre les deux. Pour commencer, j'ai sélectionné un délai d'une demi-seconde entre les étapes. Voir la courte vidéo pour les résultats. Si vous êtes vraiment dans votre jeu, comptez le nombre de pas par cycle pour déterminer la résolution angulaire à pas unique du moteur. (Oh ouais. PS. Se déplace facilement à 3,6 V sans charge. Voir la batterie dans la vidéo.)

Étape 5: balancez-le d'avant en arrière

Donc, vous l'avez fait tourner dans le sens des aiguilles d'une montre. Rien de plus intéressant ? Un petit nettoyage de code, et nous pouvons l'exécuter dans les deux sens. J'ai mis la séquence dans le sens des aiguilles d'une montre dans un tableau afin que vous puissiez parcourir les phases avec une simple boucle for. Maintenant, vous pouvez exécuter la boucle vers le haut ou vers le bas pour aller dans le sens horaire ou antihoraire.

int main(void){ const uint8_t délai = 50; const uint8_t dans le sens des aiguilles d'une montre = {BLEU, NOIR, ROUGE, JAUNE}; uint8_t i; DDRB = 0xff; /* Activer la sortie sur toutes les broches B */ PORTB = 0x00; /* Mettez-les tous à 0v */ while(1){ /* boucle principale ici */ for (i=0; i<=3; i++){ /* parcourt les couleurs dans le sens des aiguilles d'une montre */ PORTB = dans le sens des aiguilles d'une montre; _delay_ms(délai); } pour (i=3; i>=0; i--){ /* parcourt les couleurs à droite */ PORTB = dans le sens des aiguilles d'une montre; _delay_ms(délai); } }} Voir la vidéo racée pour le va-et-vient.

Étape 6: Je ne fais jamais de demi-pas, parce que je ne suis pas un demi-pas…

Les paroles de quête mises à part, c'est à demi-pas de votre moteur qu'il en est. Vous obtenez plus de courant de crête, plus de couple instantané et deux fois la résolution angulaire. Demi-pas en un mot: au lieu de Bleu, Noir, Rouge, Jaune, vous conduisez le moteur avec Bleu, Bleu+Noir, Noir, Noir+Rouge, Rouge, Rouge+Jaune, Jaune, Jaune+Bleu. Le résultat est que pendant la moitié du temps, vous engagez les deux aimants à la fois. Et pendant les moments où les deux ensembles sont engagés, le moteur pointe à mi-chemin entre les deux, réduisant l'angle entre les "pas" et faisant tourner le moteur plus doucement. Pouvez-vous dire à partir de la vidéo? Je ne suis pas sûr… Maintenant, la partie du code qui fait le demi-pas ressemble à ceci:

void halfStepping(uint16_t delay, uint8_t direction){ uint8_t i; pour (i=0; i<=3; i++){ PORTB = direction; /* partie simple bobinage */ _delay_ms(delay); PORTB |= direction[i+1]; /* ajouter en demi-pas */ _delay_ms(delay); }} La première commande PORTB définit un seul pôle sur positif et tout le reste sur négatif. Ensuite, il attend. Ensuite, la deuxième commande PORTB définit un deuxième pôle (sur l'autre enroulement) sur positif, engageant les deux enroulements pour 1,4x le couple (et 2x le courant). Une liste complète du programme est jointe ci-dessous. Deux tableaux sont maintenant définis (dans le sens des aiguilles d'une montre, dans le sens inverse des aiguilles d'une montre) et tous deux ont 5 éléments chacun pour permettre l'entrée i+1 dans la fonction halfStepping.

Étape 7: ajouter un pilote de moteur

Jusqu'ici tout va bien.

Le seul problème est que le moteur ne semble pas avoir autant de couple, ce qui pourrait être dû au fait que le microprocesseur n'émettra qu'environ 50 mA par broche. La prochaine étape évidente serait de le connecter à un pilote de moteur pour lui fournir plus de jus. Mais alors un peu de réflexion: je ne le conduis qu'avec 5v et la résistance de l'enroulement est d'environ 125 ohms. Ce qui signifie que le moteur ne consomme que 40 mA par broche et qu'il devrait être très bien entraîné par la puce AVR (costaude !). Donc, pour obtenir plus de tension entraînant le moteur, je l'ai connecté à une puce de pont en H SN754410. Le circuit est assez simple. Chaque broche de l'AVR va à une entrée et les broches de sortie correspondantes vont au moteur. La puce a besoin de 5 V pour la section logique et peut supporter beaucoup plus de tension dans la section moteur. Le faire fonctionner sur 11.25v (trois batteries 3.6v) a un peu aidé. Visiblement plus de couple à mon doigt, mais ce n'est toujours pas une centrale électrique. Pas mal pour un moteur plus petit qu'un nickel, cependant. Et maintenant, le circuit est devenu un pilote de moteur pas à pas bipolaire à usage général. Ajouté le 29 novembre: a fait tourner le moteur la nuit dernière à 12 V pendant un certain temps et il a commencé à faire chaud. Je ne sais pas s'il s'agissait d'un problème de fréquence de résonance ou si c'était simplement trop de courant pour les enroulements. Dans tous les cas, soyez un peu prudent si vous conduisez ce petit moteur avec des tensions plus élevées.

Étape 8: La fin

Alors qu'est-ce que j'ai appris ? Conduire un moteur pas à pas avec un AVR (et une puce à pont en H) est assez facile, même en mode demi-pas "fantaisie".

Je ne sais pas encore ce que je vais faire avec les petits moteurs pas à pas, cependant. Aucune suggestion?