👨‍🏫 👨🏽‍🌾 🧖🏻 Apprentissage d'un mini moteur pas à pas 🤞🏽 📶 🤴🏿

Les moteurs pas à pas sont largement utilisés dans l'industrie moderne et les produits maison. Ils sont utilisés là où il est nécessaire d'assurer la précision du positionnement des composants mécaniques, sans recourir à des retours et des mesures précises.

Aujourd'hui, je veux parler d'un type spécial de moteurs pas à pas - les moteurs pas à pas miniatures, qui sont utilisés dans la construction de systèmes optiques. Nous allons examiner de plus près leur appareil et comment contrôler ces petits moteurs.

Un moteur pas à pas est un moteur électrique sans balais (sans balais) avec plusieurs enroulements (phases) situés sur le stator et des aimants (souvent permanents) sur le rotor. En appliquant une tension aux enroulements du stator, nous pouvons fixer la position du rotor, et en appliquant une tension aux enroulements, nous pouvons obtenir successivement le mouvement du rotor d'une position à une autre (étape), et cette étape a une valeur angulaire fixe.

Nous ne nous attarderons pas sur la considération de chaque type de moteur pas à pas. Beaucoup a été écrit à ce sujet sur le réseau et bien, par exemple, ici .

Je veux parler d'un type spécial de moteurs pas à pas - les moteurs pas à pas miniatures, qui sont utilisés dans la construction de systèmes optiques. Ces enfants sont disponibles à la vente. Mais sur le réseau, surtout en russophone, il y a très peu d'informations sur ces moteurs. Par conséquent, lorsque j'ai eu besoin de les utiliser dans mon projet, j'ai dû chercher des informations et mener quelques expériences.

Je partagerai les résultats de mes recherches et expériences dans cet article.

Nous considérerons la gestion de ces petits moteurs, à savoir:

pilote L293D + microcontrôleur ATtiny44;
Pilote TMC2208 + microcontrôleur ATtiny44;
microcontrôleur ATtiny44 (sans pilote).

En fait, seul le dernier point peut poser des questions ici. Croyez-moi, j'ai également été surpris lorsque je suis tombé sur un clip vidéo (le voici ), où le gars prend juste et accroche directement le moteur pas à pas aux broches du microcontrôleur! Mais parlons de tout dans l'ordre.

Connaissance

Tout d'abord, jetez un œil à l'apparence de notre héros:

il est vraiment très petit! Selon le livre intelligent Petrenko S.F.
"Les moteurs piézoélectriques dans l'instrumentation", les petits moteurs électromagnétiques, en principe, il est impossible de créer ... c'est-à-dire, c'est possible, mais avec une diminution du diamètre du fil à partir duquel les enroulements sont fabriqués, de plus en plus d'énergie est dissipée sous forme de chaleur dans l'environnement, ce qui entraîne une diminution de l'efficacité du moteur et fait leur utilisation est irrationnelle.

Parmi les remarquables, on peut noter que son arbre est très court et possède une rainure spéciale pour l'installation de l'engrenage ou du levier.

Deux enroulements sont clairement visibles, qui sont même recouverts d'une isolation de différentes couleurs. Donc, notre moteur appartient très probablement à la classe des moteurs pas à pas bipolaires.
Voyons comment cela fonctionne:

je pense que notre connaissance de ces moteurs ne sera pas complète si nous ne voyons pas ce qu'il y a à l'intérieur. Il est toujours intéressant de regarder à l'intérieur du mécanisme! N'est-ce pas?

En fait, nous n'avons rien vu d'inhabituel. Le rotor est magnétisé. Il n'y a aucun roulement nulle part, tout est sur les coussinets. Le moyeu arrière est enfoncé dans le carter moteur. L'avant n'est fixé par rien. Fait intéressant, le corps du moteur a été assemblé par soudage par points. Il a donc fallu couper le capot avant.

Passons maintenant à la question de la connexion et de ses caractéristiques électriques.

Assurez-vous qu'il est bipolaire en faisant sonner les enroulements. Vraiment bipolaire, comme dans l'image ci-dessus. La résistance d'enroulement est d'environ 26 ohms , bien que le vendeur ait indiqué 14 ohms.
La description indique que la tension d'alimentation est de 5V . Bien que nous sachions tous que pour un moteur pas à pas, le courant consommé par ses enroulements est important.
Nous essayons de nous connecter.

Expérience n ° 1. L293D + ATtiny44

Comme nous le savons, pour contrôler un moteur pas à pas bipolaire, il est nécessaire non seulement d'appliquer une tension aux deux enroulements dans la séquence souhaitée, mais également de changer la direction du courant dans ces enroulements, et de le faire indépendamment l'un de l'autre. Pour cela, chaque enroulement a besoin de son propre pont en H. Afin de ne pas le barrer des transistors, une puce L293D prête à l'emploi a été prise. Un autre de ses avantages - la puce a des broches spéciales Enable1 et Enable2, qui activent et désactivent chaque pont. Ils peuvent être utilisés pour fournir un signal PWM, ainsi, il est possible de contrôler la tension d'alimentation de chaque pont. Pourquoi cela pourrait être nécessaire, nous verrons plus loin.

De plus, le L293D peut commuter des tensions jusqu'à 36 V et produire jusqu'à 1,2 A par canal, ce qui devrait être suffisant pour alimenter les enroulements de notre moteur.

Donc, le schéma:

Les entrées de contrôle du L293D sont connectées aux sorties OC0A et OC0B, ce qui nous permettra de leur envoyer un signal PWM à l'avenir.

Nous flasherons le contrôleur via le programmateur en circuit (non représenté sur le schéma).
Voici à quoi ressemble le circuit assemblé sur une planche à pain:

Et voici comment se trouve notre

pilote d' essai: vous pouvez maintenant commencer à expérimenter.

Nous calculons le courant qui traversera les enroulements du moteur lorsqu'ils sont connectés à une tension de 5V:

I = U / R = 5V / 26Ohm = 190mA

Très petit. Je me demande combien de temps il peut maintenir un tel courant et ne pas surchauffer.

Nous incluons un ampèremètre et un voltmètre dans le circuit de l'un des enroulements, et mesurons les valeurs correspondantes lorsque l'alimentation de cet enroulement est fournie par le conducteur.

Lorsque la tension chute à travers l'enroulement de 2,56 V, l'ampèremètre affiche un courant de 150 mA , et il est clairement visible comment l'amplitude du courant commence à chuter pendant le chauffage des enroulements. Il faut noter qu'il ne fait pas si chaud.

Après vous être assuré que la tension de 5 V du moteur n'est pas dangereuse, essayez de les tordre dans différentes directions. Et maintenant, nous allons dire quelques mots sur les modes de fonctionnement du moteur pas à pas.

C'est assez bien dit ici .

Nous ne répéterons pas, mais rappelons qu'un moteur pas à pas peut fonctionner en trois modes:

, , .
, , , .
, , , ( ) . , , ( , , ). .

Essayons d'implémenter les deux premiers modes sur la puce L293D, et pour le mode micro-pas, nous laisserons un pilote spécial de la deuxième expérience.

Le code source du programme est le suivant:

Code source WinAVR

#define F_CPU 8000000UL  //    

//    L: E2; H:DF; Ex:FF; 
//    8         (     8)

#include <avr/io.h> //   

#include <util/delay.h> //   

#include <avr/interrupt.h> //   

//   

#define LED_pin PA5

#define LED_ON PORTA |=(1<<LED_pin)

#define LED_OFF PORTA &=(~(1<<LED_pin))

//     L293DD

#define PWM_1 PB2 // OC0A (EN1)

#define PWM_2 PA7 // OC0B (EN2)

#define PWM_1_value OCR0A

#define PWM_2_value OCR0B

//       L293D

#define IN1 PA0 //  PORTA

#define IN2 PA1

#define IN3 PB1 //  PORTB

#define IN4 PB0

void delay_microsecond (unsigned int delay_time) { //     
    
	//      

    for(unsigned int delay_us = 0; delay_us<delay_time; delay_us++) {
	
	    _delay_us(1);
	
	}

}

void delay_millisecond (unsigned int delay_time) { //     

    for(unsigned int delay_ms = 0; delay_ms<delay_time; delay_ms++) {
	
	    _delay_ms(1);
	
	}

}

//      

void step_1_one_phase (void) {

    PORTB &=(~((1<<IN3)|(1<<IN4)));
	
	PORTA &=(~(1<<IN2)); //   
  
    PORTA |=(1<<IN1); //    
}

void step_2_one_phase (void) {

    PORTA &=(~((1<<IN1)|(1<<IN2)));
	
	PORTB &=(~(1<<IN3));
  
    PORTB |=(1<<IN4);
  
}

void step_3_one_phase (void) {

    PORTB &=(~((1<<IN3)|(1<<IN4))); 
	 
	PORTA &=(~(1<<IN1));
  
    PORTA |=(1<<IN2);
  
	
}

void step_4_one_phase (void) {

    PORTA &=(~((1<<IN1)|(1<<IN2))); 
	
	PORTB &=(~(1<<IN4));
    
    PORTB |=(1<<IN3);
  
}

//      

void step_1_two_phase (void) {

    PORTB |=(1<<IN4);  
  
    PORTB &=(~(1<<IN3));
  
    PORTA |=(1<<IN1);
  
    PORTA &=(~(1<<IN2));
}

void step_2_two_phase (void) {

    PORTA &=(~(1<<IN2));//2
	
	PORTA |=(1<<IN1);
  
    PORTB |=(1<<IN3);
  
    PORTB &=(~(1<<IN4));
  
}

void step_3_two_phase (void) {

    PORTB |=(1<<IN3);//3
  
    PORTB &=(~(1<<IN4));
	
	PORTA &=(~(1<<IN1));
  
    PORTA |=(1<<IN2);
  
	
}

void step_4_two_phase (void) {

    PORTA |=(1<<IN2);//4
  
    PORTA &=(~(1<<IN1));
    
    PORTB |=(1<<IN4);
  
    PORTB &=(~(1<<IN3));
  
}

void stepper_OFF (void) { //   

	//    ,       ,    
	
	PORTA &=(~((1<<IN1)|(1<<IN2)));
	
	PORTB &=(~((1<<IN3)|(1<<IN4)));
	
}

unsigned char step_counter = 0; 

//      

void L293D_step (unsigned int step_quantity, unsigned char direction, unsigned int step_delay, unsigned char phase) { //      

    while(step_quantity>0) { //  ,      

        switch(direction) { //           
	
			case 'F':
				if(step_counter<3) { step_counter++; } else { step_counter=0; }
			break;
		
			case 'B':
				if(step_counter>0) { step_counter--; } else { step_counter=3; }
			break;
		
		}
		
		switch(phase) { //     
		
		    case 1: 
			
				switch(step_counter) { //   
	
					case 0:
						step_1_two_phase_DL();
					break;
		
					case 1:
						step_2_two_phase_DL();
					break;
		
					case 2:
						step_3_two_phase_DL();
					break;
		
					case 3:
						step_4_two_phase_DL();
					break;
	
				}
			
			break;
			
			case 2:
			
				switch(step_counter) { //   
	
					case 0:
						step_1_two_phase_DL();
					break;
		
					case 1:
						step_2_two_phase_DL();
					break;
		
					case 2:
						step_3_two_phase_DL();
					break;
		
					case 3:
						step_4_two_phase_DL();
					break;
	
				}
			
			break;
		
		}
		
    delay_millisecond(step_delay); //       
	
	step_quantity--; 
	
	} 

}


void PWM_init (void) { //   

    DDRB |=(1<<PWM_1);

    DDRA |=(1<<PWM_2);

    TCCR0A = (1<<WGM01)|(1<<WGM00)|(1<<COM0A1)|(0<<COM0A0)|(1<<COM0B1)|(0<<COM0B0); //  FAST PWM,   
	
    TCCR0B = (0<<WGM02)|(0<<CS02)|(0<<CS01)|(1<<CS00); //   8
	
    OCR0A = 255; //    (0-255)

    OCR0B = 255;

} //    

int main (void) { 

    DDRA |=(1<<LED_pin);
	
    DDRA |=(1<<IN1)|(1<<IN2);

    DDRB |=(1<<IN3)|(1<<IN4);
	
    PWM_init(); //  
	
    delay_millisecond(2000);
	
    while(1==1) { 
	   
	LED_ON;
		
        L293D_step(16,'F',100,2); //step( ,  F/B,   , / )
		
	//stepper_OFF();
		
	delay_millisecond(2000);
		
	LED_OFF;
		
	L293D_step(16,'B',100,2);
		
	//stepper_OFF();
		
	delay_millisecond(2000);
		  
    } 

}

Mode pas à pas. Monophasé

Le moteur prend 16 pas par tour. De plus, les étapes des deux phases n'ont pas la même valeur angulaire. Je ne sais pas à quoi cela est lié. Peut-être que la conception du moteur est la suivante?

Examinons la fréquence maximale d'étapes qu'il peut fournir dans ce mode sans les manquer.

Le délai minimum entre les étapes est de 2 ms, ce qui signifie 500 étapes / seconde. Pas mal, c'est 31 rpm = 1850 rpm.

Mode pas à pas. Deux phases

Veuillez noter que dans ce cas, les étapes sont plus lisses, elles sont de taille identique (en tout cas, plus identiques que dans le cas précédent).

Naturellement, dans ce cas, deux enroulements sont simultanément alimentés et le transfert de chaleur augmente. Après quelques secondes, le moteur chauffe assez fortement, j'ai donc arrêté l'expérience.

Et avec la fréquence maximale des pas? 500 pas / seconde; 31 tr / min = 1875 tr / min.
Il faut dire que pour un moteur pas à pas c'est assez agile. Cela est dû au petit nombre de pôles magnétiques sur le rotor.

Nous continuons ...

Expérience numéro 2. TMC2208 + ATtiny44

TMC2208 est le nom d'une puce pilote pour contrôler les moteurs pas à pas bipolaires, un module basé sur celui-ci est également appelé, qui est produit pour être installé dans des imprimantes 3D faites maison (et pas seulement) et a une disposition de broches unifiée.
Beaucoup et lucidement dit sur ce module ici .

Beaucoup a été écrit sur Internet sur la façon de l'installer dans votre imprimante 3D, mais nous sommes intéressés par la façon de connecter le module au microcontrôleur, alors comprenons.

Les caractéristiques de la puce sont impressionnantes (uniquement les personnes impressionnables):

tension d'alimentation de la partie logique: 3-5V;
tension d'alimentation du moteur 5,5-36 V;
courant de crête 2A;
réglage du courant moteur maximum;
Prise en charge de l'interface UART pour la gestion et la configuration des registres internes;
arrêt automatique;
prise en charge du mode micropas de contrôle moteur jusqu'à 1/16 de pas.

C'est très simple à gérer, en fait, vous n'avez besoin que de deux broches du microcontrôleur. L'un est connecté à DIR - nous indiquons le sens de rotation du moteur, l'autre est connecté à STEP - lorsqu'une impulsion est appliquée, le microcircuit effectue les manipulations nécessaires avec des courants et des tensions sur les enroulements du moteur et cela prend une étape.

Le schéma de connexion ressemblera à ceci:

De plus, j'ai utilisé la broche EN pour éteindre le moteur et pendant longtemps pour ne pas garder les enroulements sous tension.

Code source WinAVR

#define F_CPU 8000000UL  //    

//    L: E2; H:DF; Ex:FF; 
//    8         (     8)

#include <avr/io.h> //   

#include <util/delay.h> //   

#include <avr/interrupt.h> //   

//   

#define LED_pin PA5

#define LED_ON PORTA |=(1<<LED_pin)

#define LED_OFF PORTA &=(~(1<<LED_pin))

//     TMC2208

#define DIR PB2

#define EN PA6

#define STP PA7

#define EN_OFF PORTA |=(1<<EN)

#define EN_ON PORTA &=(~(1<<EN))

#define DIR_FOR PORTB |=(1<<DIR)

#define DIR_BACK PORTB &=(~(1<<DIR))

#define STP_ON PORTA |=(1<<STP)

#define STP_OFF PORTA &=(~(1<<STP))

void delay_microsecond (unsigned int delay_time) { //     
    
	//      

    for(unsigned int delay_us = 0; delay_us<delay_time; delay_us++) {
	
	    _delay_us(1);
	
	}

}

void delay_millisecond (unsigned int delay_time) { //     

    for(unsigned int delay_ms = 0; delay_ms<delay_time; delay_ms++) {
	
	    _delay_ms(1);
	
	}

}

void TMS2208_STEP (unsigned int step_quantity, unsigned char direction, unsigned int step_delay) {

    switch(direction) { //  
	
		case 'F':
			DIR_FOR;	
		break;
		
		case 'B':
			DIR_BACK;	
		break;
		
	}

    while(step_quantity>0) { //      
	
		STP_ON; //   
		
		delay_microsecond(100); //   100
		
		STP_OFF;
		
		delay_millisecond(step_delay);//   
	
	    step_quantity--;
	
	}

}

int main (void) {

        DDRA |=(1<<LED_pin);

        DDRB |=(1<<DIR);

        DDRA |=(1<<EN);

        DDRA |=(1<<STP);
	
	PWM_init(); //  
	
	delay_millisecond(2000);
	
	while(1==1) { 
	   
	   LED_ON;
	   
	   EN_ON;
	
	   TMS2208_STEP(32,'F',10); // TMS2208_STEP ( ,  F/B,   )
	   
	   delay_millisecond(2000);
	   
	   LED_OFF;
	   
	   TMS2208_STEP(32,'B',10);
	   
	   delay_millisecond(2000);
	
	   
	} 

}

Avant de tout démarrer, vous devez pré-configurer le module. Tout d'abord, définissez le mode micropas souhaité. Deuxièmement, réglez le courant moteur maximal souhaité.

Avec un micropas, tout est simple. Les broches MS1 et MS2 en sont responsables.

Je note que le microcircuit ne modifie pas la tension pas à pas, mais le fait «en douceur», mais comme le microcircuit est numérique, la sortie n'est pas un signal lisse, mais un signal avec un petit pas, selon la documentation, il décompose chaque pas en 256 micro pas. Cela a été fait pour augmenter la douceur de roulement, réduire le bruit du moteur et, en théorie, ne devrait pas permettre à la structure sur laquelle il est vissé d'entrer en résonance. Bref, tout cela pour rendre l'imprimante 3D plus silencieuse.

Pour régler le courant du moteur, il est nécessaire de mesurer la tension au contact Vref, ce qui est indiqué sur la figure. La valeur de la tension peut être modifiée à l'aide d'un potentiomètre installé à côté du contact. La tension au contact sera proportionnelle au courant du moteur, et la dépendance aura la forme suivante:

Vref = I * 1,44;

Notre moteur a besoin d'environ 150mA, car Vref = 0,216V . Nous installons ...

Il est entendu qu'une augmentation de courant fournit le microcircuit en augmentant la tension aux bornes de l'enroulement. Par conséquent, vous devez vous assurer que cette tension est suffisante. Mais, je crois, 5V devrait être suffisant pour ce petit moteur.

Nous allons tester le fonctionnement du moteur avec différents modes de micropas et voir ce qui se passe (la pause entre les micropas est de 10 ms):

Vous pouvez remarquer que les mouvements du moteur sont devenus plus fluides (par rapport à l'expérience précédente), cependant, les 16 étapes caractéristiques sont encore assez clairement observées. Eh bien ... apparemment, c'est une caractéristique des moteurs pas à pas avec un rotor à aimant permanent .
Il convient également de noter que le moteur dans ce mode chauffe presque autant que dans un mode à pas complet à deux phases. C'est compréhensible, les enroulements sont constamment alimentés, de la chaleur est continuellement générée.

Je pense que pour de tels moteurs, l'utilisation d'un tel pilote, et en fait de modes micropas, n'est pas très recommandée.

Expérience numéro 3. Pilote ATtiny44

Revenons brièvement à la première expérience et rappelons que les entrées EN1 et EN2 du microcircuit pilote sont connectées aux broches OC0A et OC0B du microcontrôleur. Cela signifie que nous pouvons y envoyer un signal PWM généré à l'aide de la minuterie TIMER0 et ainsi changer la tension appliquée aux enroulements du moteur et réguler en conséquence le courant qui les traversera.

Selon la fiche technique du microcontrôleur ATtiny44, le courant maximal qu'une broche peut fournir n'est que de 40 mA. De plus, il n'est pas indiqué pour quel type de courant (pulsé ou constant) cette caractéristique. C'est juste là et c'est comme ça ... Je

dois dire que je connais les microcontrôleurs ATMEL depuis plus de 7 ans. Et jamais une seule fois je n'ai eu envie de vérifier cette ligne de la fiche technique.

Peut-être que le fabricant est juste sûr et qu'il peut en donner plus, ou peut-être que c'est vraiment le maximum qui peut donner une broche.

Nous allons découvrir. Mais vous devez d'abord savoir à quel courant minimum le moteur est généralement capable de tourner.

En utilisant le circuit de la première expérience, nous ajustons la valeur du courant à travers les enroulements égale à 40 mA. On commence en mode pas à pas avec deux phases (car le couple sera plus élevé):

Excellent! À 40mA, le moteur a démarré avec succès! La valeur minimale du courant d'enroulement nécessaire au fonctionnement stable du moteur a également été détectée, et elle est égale à 30mA.

Bien sûr, le couple sera beaucoup plus faible, mais le fait que nous ayons réussi à démarrer le moteur avec une si petite consommation d'énergie est important pour nous.

Le schéma de connexion du moteur pas à pas au microcontrôleur sera le suivant:

Étant donné que chaque broche du microcontrôleur fonctionne comme un demi-pont (il peut commuter la sortie du microcircuit sur Vcc ou GND), pour contrôler le moteur pas à pas bipolaire, nous avons besoin de 4 broches du microcontrôleur.

Code de programme:

Code source WinAVR

#define F_CPU 8000000UL  //    

//    L: E2; H:DF; Ex:FF; 
//    8         (     8)

#include <avr/io.h> //   

#include <util/delay.h> //   

#include <avr/interrupt.h> //   

//   

#define LED_pin PA5

#define LED_ON PORTA |=(1<<LED_pin)

#define LED_OFF PORTA &=(~(1<<LED_pin))

//     L293DD

#define PWM_1 PB2 // OC0A (EN1)

#define PWM_2 PA7 // OC0B (EN2)

#define PWM_1_value OCR0A

#define PWM_2_value OCR0B

//       L293D

#define IN1 PA0 //  PORTA

#define IN2 PA1

#define IN3 PB1 //  PORTB

#define IN4 PB0


void delay_microsecond (unsigned int delay_time) { //     
    
	//      

    for(unsigned int delay_us = 0; delay_us<delay_time; delay_us++) {
	
	    _delay_us(1);
	
	}

}

void delay_millisecond (unsigned int delay_time) { //     

    for(unsigned int delay_ms = 0; delay_ms<delay_time; delay_ms++) {
	
	    _delay_ms(1);
	
	}

}

//        

void step_1_two_phase_DL (void) { // DL - driver less
   
   //  
   OCR0A = 160;
   PORTB &=(~(1<<IN4)); 
   
   //  
   OCR0B = 160;
   PORTB &=(~(1<<IN3)); 
    
}

void step_2_two_phase_DL (void) { 
   
   //  
   OCR0A = 160;
   PORTB &=(~(1<<IN4)); 
   
   //  
   OCR0B = 95;
   PORTB |=(1<<IN3); 
    
}

void step_3_two_phase_DL (void) { 
   
   //  
   OCR0A = 95;
   PORTB |=(1<<IN4); 
   
   //  
   OCR0B = 95;
   PORTB |=(1<<IN3); 
    
}

void step_4_two_phase_DL (void) { 
   
   //  
   OCR0A = 95;
   PORTB |=(1<<IN4); 
   
   //  
   OCR0B = 160;
   PORTB &=(~(1<<IN3)); 
    
}

unsigned char step_counter = 0; 

//      

void L293D_step (unsigned int step_quantity, unsigned char direction, unsigned int step_delay, unsigned char phase) { //      

    while(step_quantity>0) { //  ,      

        switch(direction) { //           
	
			case 'F':
				if(step_counter<3) { step_counter++; } else { step_counter=0; }
			break;
		
			case 'B':
				if(step_counter>0) { step_counter--; } else { step_counter=3; }
			break;
		
		}
		
		switch(phase) { //     
		
		    case 1: 
			
				switch(step_counter) { //   
	
					case 0:
						step_1_two_phase_DL();
					break;
		
					case 1:
						step_2_two_phase_DL();
					break;
		
					case 2:
						step_3_two_phase_DL();
					break;
		
					case 3:
						step_4_two_phase_DL();
					break;
	
				}
			
			break;
			
			case 2:
			
				switch(step_counter) { //   
	
					case 0:
						step_1_two_phase_DL();
					break;
		
					case 1:
						step_2_two_phase_DL();
					break;
		
					case 2:
						step_3_two_phase_DL();
					break;
		
					case 3:
						step_4_two_phase_DL();
					break;
	
				}
			
			break;
		
		}
		
    delay_millisecond(step_delay); //       
	
	step_quantity--; 
	
	} 

}


void PWM_init (void) { //   

    DDRB |=(1<<PWM_1); 
	
    DDRA |=(1<<PWM_2);

    TCCR0A = (1<<WGM01)|(1<<WGM00)|(1<<COM0A1)|(0<<COM0A0)|(1<<COM0B1)|(0<<COM0B0); //  FAST PWM,   
	
    TCCR0B = (0<<WGM02)|(0<<CS02)|(0<<CS01)|(1<<CS00); //   8
	
    OCR0A = 160; 
	
    OCR0B = 160;

} //    

int main (void) { //  

    DDRA |=(1<<LED_pin);
	
	DDRA |=(1<<IN1)|(1<<IN2);
	
	DDRB |=(1<<IN3)|(1<<IN4);
	
	PWM_init(); //  
	
	delay_millisecond(2000);
	
	while(1==1) { //  

	    LED_ON;
		
	    L293D_step(16,'F',100,2); //step( ,  F/B,   , / )
		
            delay_millisecond(2000);
		
	    LED_OFF;
		
	    L293D_step(16,'B',100,2);
		
	    delay_millisecond(2000);
		
	
	   
	} 

}

Permettez-moi d'expliquer un peu comment ce programme fonctionne. Il s'agit d'un code modifié de la première expérience. Comme je l'ai dit plus haut, un TIMER0 8 bits sera utilisé pour générer un signal PWM aux sorties OC0A et OC0B. La minuterie est réglée sur le mode FastPWM avec un pré-échelle de 8 (la fréquence du signal à 8 MHz de l'horloge du microcontrôleur est de 3906 Hz).

Pour changer la polarité des signaux sur les enroulements, la broche du microcontrôleur est commutée de Vcc à GND en changeant le bit correspondant dans le registre PORTx et en changeant le rapport cyclique PWM en écrivant des valeurs dans les registres OCR0A et OCR0B (les valeurs ont été sélectionnées expérimentalement).

Et donc:

Un cours sur les circuits pris au cours de la première année de l'institut suggère que le multimètre affiche la valeur efficace de la tension et du courant dans le moteur.

Le moteur pas à pas tourne à partir des broches du microcontrôleur sans pilotes!

Mais ici, nous n'allons pas au-delà des capacités du microcontrôleur, du moins, selon ce qui est écrit dans la documentation. Dans ce mode, le microcontrôleur et le moteur peuvent fonctionner pendant longtemps. En effet, l'expérience a duré 20 minutes. Pendant ce temps, il n'y a eu aucune étape de saut, aucune réinitialisation du contrôleur ou surchauffe (ni le moteur ni le contrôleur).

Mettez de côté toutes les précautions

Nous retirons le PWM de l'expérience et nous contrôlerons directement les broches du microcontrôleur à l'aide des registres PORTx. Voyons ce qui arrive au microcontrôleur après cela.

Cela fonctionne ... avec un courant maximum de 51mA ... Eh bien ... de façon inattendue, il semble que ce soit le courant maximum que peut donner une broche du microcontrôleur? Si je me trompe, corrigez-moi.

En tout cas, la vidéo de YouTube n'a pas été trompée. En effet, vous pouvez contrôler ce moteur sans aucun pilote .

résultats

Nous avons étudié en détail les moteurs pas à pas bipolaires miniatures, leur conception et comment les contrôler, pour une utilisation dans nos propres applications.

1. Le moteur pas à pas bipolaire miniature avec un rotor à aimant permanent est vraiment miniature.

Ses principales caractéristiques:

, , ( , , 16);
( ), 1875 /;
( );

2. Le moteur pas à pas miniature peut être contrôlé par n'importe quel pilote adapté pour travailler avec des moteurs pas à pas bipolaires, il vous suffit de sélectionner les paramètres de courant d'enroulement.

3. L'utilisation d'un pilote TMC2208 spécialisé est un problème controversé, car le mode micropas n'est pas pris en charge par le moteur lui-même, bien que les transitions entre les étapes soient effectuées plus en douceur.

4. Il est possible de connecter un moteur pas à pas directement aux ports du microcontrôleur. Mais ce n'est que dans le cadre de l'expérience, car le couple dans ce cas est très insignifiant, et même un petit courant ne permet pas de faire des pas à grande vitesse.

La prochaine fois, je vais vous expliquer pourquoi nous avions besoin de si petits moteurs pas à pas.

Apprentissage d'un mini moteur pas à pas

Connaissance

Expérience n ° 1. L293D + ATtiny44

Mode pas à pas. Monophasé

Mode pas à pas. Deux phases

Expérience numéro 2. TMC2208 + ATtiny44

Expérience numéro 3. Pilote ATtiny44

Mettez de côté toutes les précautions

résultats

More articles: