☁️ 👊🏼 👩🏾‍💼 Aprendiendo un Mini Motor Paso a Paso 📉 👨🏾‍🤝‍👨🏼 🦗

Los motores paso a paso son ampliamente utilizados en la industria moderna y en productos caseros. Se utilizan donde es necesario garantizar la precisión del posicionamiento de los componentes mecánicos, sin recurrir a la retroalimentación y a mediciones precisas.

Hoy quiero hablar sobre un tipo especial de motores paso a paso: motores paso a paso en miniatura, que se utilizan en la construcción de sistemas ópticos. Echaremos un vistazo más de cerca a su dispositivo y cómo controlar motores tan pequeños.

Un motor paso a paso es un motor eléctrico sin escobillas (sin escobillas) con varios devanados (fases) ubicados en el estator e imanes (a menudo permanentes) en el rotor. Al aplicar voltaje a los devanados del estator, podemos fijar la posición del rotor, y al aplicar voltaje a los devanados, podemos obtener sucesivamente el movimiento del rotor de una posición a otra (paso), y este paso tiene un valor angular fijo.

No nos detendremos en la consideración de cada tipo de motor paso a paso. Mucho se ha escrito sobre esto en la red y bueno, por ejemplo, aquí .

Quiero hablar sobre un tipo especial de motores paso a paso: motores paso a paso en miniatura, que se utilizan en la construcción de sistemas ópticos. Estos niños están disponibles para la venta. Pero en la red, especialmente en los de habla rusa, hay muy poca información sobre tales motores. Por lo tanto, cuando necesitaba usarlos en mi proyecto, tenía que buscar información y realizar un par de experimentos.

Compartiré los resultados de mis búsquedas y experimentos en este artículo.

Consideraremos la gestión de tales motores pequeños, a saber:

controlador L293D + microcontrolador ATtiny44;
Controlador TMC2208 + microcontrolador ATtiny44;
microcontrolador ATtiny44 (sin controlador).

En realidad, solo el último punto puede causar preguntas aquí. Créeme, también me sorprendió cuando me encontré con un video clip ( aquí está ), ¡donde el tipo simplemente levanta y engancha directamente el motor paso a paso a los pines del microcontrolador! Pero hablemos de todo en orden.

Conocido

Primero, un pequeño vistazo a la apariencia de nuestro héroe:

¡es realmente muy pequeño! Según el libro inteligente Petrenko S.F.
"Motores piezoeléctricos en instrumentación", motores electromagnéticos más pequeños, en principio, es imposible de crear ... es decir, es posible, pero con una disminución en el diámetro del cable del que están hechos los devanados, se disipa más y más energía como calor en el medio ambiente, lo que conduce a una disminución en la eficiencia del motor y hace Su uso es irracional.

De lo notable, se puede notar que su eje es muy corto y tiene una ranura especial para instalar el engranaje o la palanca.

Dos bobinados son claramente visibles, que incluso están cubiertos con aislamiento de diferentes colores. Entonces, nuestro motor probablemente pertenece a la clase de motores paso a paso bipolares.
Veamos cómo funciona:

creo que nuestro conocimiento de estos motores no estará completo si no vemos lo que hay dentro de él. ¡Siempre es interesante mirar dentro del mecanismo! ¿No es así?

En realidad, no vimos nada inusual. El rotor está magnetizado. No hay cojinetes en ningún lado, todo está en los bujes. El cubo trasero se presiona en la carcasa del motor. El frente no está fijado por nada. Curiosamente, el cuerpo del motor se ensambló mediante soldadura por puntos. Entonces la portada tuvo que ser cortada.

Ahora pasamos al tema de la conexión y sus características eléctricas.

Asegúrate de que sea bipolar tocando los devanados. Realmente bipolar, como en la imagen de arriba. La resistencia del devanado es de aproximadamente 26 ohmios , aunque el vendedor indicó 14 ohmios.
La descripción dice que el voltaje de alimentación es de 5V . Aunque todos sabemos que para un motor paso a paso, la corriente que consumirán sus devanados es importante.
Estamos intentando conectarnos.

Experimento No. 1. L293D + ATtiny44

Como sabemos, para controlar un motor paso a paso bipolar, es necesario no solo aplicar voltaje a los dos devanados en la secuencia deseada, sino también cambiar la dirección de la corriente en estos devanados, y hacerlo independientemente uno del otro. Para esto, cada devanado necesita su propio puente H. Para no sacarlo de los transistores, se tomó un chip L293D listo para usar. Otra de sus ventajas: el chip tiene pines especiales Enable1 y Enable2, que activan y desactivan cada puente. Se pueden usar para proporcionar una señal PWM, por lo tanto, es posible controlar el voltaje de alimentación de cada puente. Por qué esto puede ser necesario, veremos más.

Además, el L293D puede cambiar voltajes de hasta 36V y producir hasta 1.2A por canal, que debería ser suficiente para alimentar los devanados de nuestro motor.

Entonces, el diagrama:

las entradas de control L293D están conectadas a las salidas OC0A y OC0B, lo que nos permitirá enviarles una señal PWM en el futuro.

Destellaremos el controlador a través del programador en circuito (no se muestra en el diagrama).
Así es como se ve el circuito ensamblado en una placa de

pruebas : así es como se encuentra nuestro

piloto de prueba: ahora puede comenzar a experimentar.

Calculamos la corriente que fluirá a través de los devanados del motor cuando están conectados a un voltaje de 5V:

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

Muy pequeño. Me pregunto cuánto tiempo puede aguantar tanta corriente y no sobrecalentarse.

Incluimos un amperímetro y un voltímetro en el circuito de uno de los devanados, y medimos los valores correspondientes cuando se suministra energía a este devanado a través del controlador.

Cuando el voltaje cae a través del devanado de 2.56V, el amperímetro muestra una corriente de 150 mA , y es claramente visible cómo la magnitud de la corriente comienza a caer durante el calentamiento de los devanados. Cabe señalar que no hace tanto calor.

Después de asegurarse de que el voltaje de 5 V para el motor no sea peligroso, intente girarlos en diferentes direcciones. Y ahora algunas palabras que diremos sobre los modos de operación del motor paso a paso.

Esto está bastante bien dicho aquí .

No repetiremos, pero recuerde que un motor paso a paso puede funcionar en tres modos:

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

Intentemos implementar los primeros dos modos en el chip L293D, y para el modo de micropaso, dejaremos un controlador especial del segundo experimento.

El código fuente del programa es el siguiente:

Código fuente de 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);
		  
    } 

}

Modo paso completo Fase única

El motor da 16 pasos por revolución. Además, los pasos para las dos fases no tienen el mismo valor angular. No sé con qué está conectado. Tal vez el diseño del motor es este?

Veamos la frecuencia máxima de pasos que puede proporcionar en este modo sin perderlos.

El retraso mínimo entre pasos es de 2 ms, lo que significa 500 pasos / segundo. No está mal, son 31 rpm = 1850 rpm.

Modo paso completo Dos fases

Tenga en cuenta que en este caso los pasos son más suaves, son del mismo tamaño (en cualquier caso, más iguales que en el caso anterior).

Naturalmente, en este caso, dos bobinados se energizan simultáneamente y aumenta la transferencia de calor. Después de unos segundos, el motor se calienta bastante, así que detuve el experimento.

¿Qué pasa con la frecuencia máxima de pasos? 500 pasos / segundo; 31 rpm = 1875 rpm.
Hay que decir que para un motor paso a paso es bastante ágil. Esto se debe al pequeño número de polos magnéticos en el rotor.

Continuamos ...

Experimento número 2. TMC2208 + ATtiny44

TMC2208 es el nombre de un chip controlador para controlar motores paso a paso bipolares, llamado de manera similar un módulo basado en él, que se produce para la instalación en impresoras 3D caseras (y no solo) y tiene un diseño de pin unificado.
Mucho y lúcidamente dijo sobre este módulo aquí .

Se ha escrito mucho en Internet sobre cómo instalarlo en su impresora 3D, pero estamos interesados en cómo conectar el módulo al microcontrolador, así que comprendamos.

Las características del chip son impresionantes (solo personas impresionables):

tensión de alimentación de la parte lógica: 3-5V;
tensión de alimentación del motor 5.5-36V;
corriente pico 2A;
ajuste de la corriente máxima del motor;
Soporte de interfaz UART para gestionar y configurar registros internos;
apagado automático;
Soporte para el modo de micropasos del control del motor hasta 1/16 de un paso.

Es muy simple de administrar, de hecho, solo necesita dos pines del microcontrolador. Uno está conectado a DIR - indicamos la dirección de rotación del motor, el otro está conectado a STEP - cuando se aplica un pulso, el microcircuito realiza las manipulaciones necesarias con corrientes y voltajes en los devanados del motor y da un paso.

El diagrama de conexión se verá así:

además, usé el pin EN para apagar el motor y durante mucho tiempo para no mantener los devanados energizados.

Código fuente de 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);
	
	   
	} 

}

Antes de comenzar todo, debe preconfigurar el módulo. Primero, configure el modo de micropaso deseado. En segundo lugar, establezca la corriente máxima deseada del motor.

Con un microstep, todo es simple. Los pines MS1 y MS2 son responsables de esto.

Observo que el microcircuito no cambia el voltaje paso a paso, pero lo hace "suavemente", pero dado que el microcircuito es digital, la salida no es una señal suave, sino una señal con un pequeño paso, según la documentación, divide cada paso en 256 micro pasos. Esto se hizo para aumentar la suavidad de marcha, reducir el ruido del motor y, en teoría, no debería permitir que la estructura a la que se atornilla ingrese la resonancia. En resumen, todo para que la impresora 3D sea más silenciosa.

Para configurar la corriente del motor es necesario medir el voltaje en el contacto Vref, que se indica en la figura. El valor del voltaje se puede cambiar usando un potenciómetro instalado al lado del contacto. El voltaje en el contacto será proporcional a la corriente del motor, y la dependencia tendrá la siguiente forma:

Vref = I * 1.44;

Nuestro motor necesita alrededor de 150 mA, porque Vref = 0.216V . Instalamos ...

Se entiende que un aumento en la corriente proporciona el microcircuito al aumentar el voltaje a través del devanado. Por lo tanto, debe asegurarse de que esta tensión sea suficiente. Pero, creo, 5V debería ser suficiente para ese pequeño motor.

Probaremos el funcionamiento del motor con varios modos de microstep y veremos qué sucede (la pausa entre microsteps es de 10 ms):

Puede notar que los movimientos del motor se han vuelto más suaves (en comparación con el experimento anterior), sin embargo, los 16 pasos característicos aún se observan con bastante claridad. Bueno ... aparentemente esta es una característica de los motores paso a paso con un rotor de imán permanente .
También debe tenerse en cuenta que el motor en este modo se calienta casi tanto como en un modo de paso completo con dos fases. Es comprensible, los devanados se energizan constantemente, el calor se genera continuamente.

Creo que para tales motores, el uso de un controlador de este tipo, y de hecho modos microstep, no es muy recomendable.

Experimento número 3. ATtiny44 driver

Volvamos brevemente al primer experimento y recordemos que las entradas EN1 y EN2 del microcircuito del controlador están conectadas a los pines OC0A y OC0B del microcontrolador. Esto significa que podemos enviar allí una señal PWM generada usando el temporizador TIMER0 y así cambiar el voltaje aplicado a los devanados del motor y, en consecuencia, regular la corriente que fluirá a través de ellos.

Según la hoja de datos del microcontrolador ATtiny44, la corriente máxima que puede proporcionar un pin es de solo 40 mA. Además, no está indicado para qué tipo de corriente (pulsante o constante) esta característica. Simplemente está allí y es así ...

Debo decir que he estado familiarizado con los microcontroladores ATMEL durante más de 7 años. Y nunca tuve el deseo de revisar esta línea de la hoja de datos.

Quizás el fabricante sea seguro y, de hecho, pueda dar más, o tal vez sea realmente lo máximo que puede dar un pin.

Vamos a averiguar. Pero primero debe averiguar a qué corriente mínima generalmente puede girar el motor.

Usando el circuito del primer experimento, ajustamos el valor de la corriente a través de los devanados igual a 40 mA. Comenzamos en modo de paso completo con dos fases (ya que el par será mayor):

¡Excelente! ¡A 40 mA, el motor arrancó con éxito! También se detectó el valor mínimo de la corriente de bobinado necesaria para el funcionamiento estable del motor, y es igual a 30 mA.

Por supuesto, el par será mucho más bajo, pero el hecho de que logramos arrancar el motor con un consumo de energía tan pequeño es importante para nosotros.

El diagrama de conexión del motor paso a paso al microcontrolador será el siguiente:

dado que cada pin del microcontrolador funciona como medio puente (puede cambiar la salida del microcircuito a Vcc o GND), para controlar el motor paso a paso bipolar, necesitamos 4 pines del microcontrolador.

Código de programa:

Código fuente de 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);
		
	
	   
	} 

}

Déjame explicarte un poco cómo funciona este programa. Este es un código modificado del primer experimento. Como dije anteriormente, se usará un TIMER0 de 8 bits para generar una señal PWM en las salidas OC0A y OC0B. El temporizador está configurado en modo FastPWM con un preescalador de 8 (la frecuencia de señal a 8 MHz del reloj del microcontrolador es 3906 Hz).

Para cambiar la polaridad de las señales en los devanados, el pin del microcontrolador se cambia de Vcc a GND cambiando el bit correspondiente en el registro PORTx y cambiando el ciclo de trabajo PWM escribiendo valores en los registros OCR0A y OCR0B (los valores se seleccionaron experimentalmente).

Y entonces:

Un curso de circuito realizado en el primer año del instituto sugiere que el multímetro muestra el valor eficaz de la tensión y la corriente en el motor.

¡El motor paso a paso gira desde los pines del microcontrolador sin controladores!

Pero aquí no vamos más allá de las capacidades del microcontrolador, al menos, de acuerdo con lo que está escrito en la documentación. En este modo, el microcontrolador y el motor pueden funcionar durante mucho tiempo. De hecho, el experimento duró 20 minutos. Durante este tiempo, no hubo pasos de omisión, ni reinicio del controlador ni sobrecalentamiento (ni el motor ni el controlador).

Deja de lado todas las precauciones

Eliminamos el PWM del experimento y controlaremos directamente los pines del microcontrolador utilizando los registros PORTx. Veamos qué pasa con el microcontrolador después de eso.

Funciona ... con una corriente máxima de 51 mA ... Bueno ... inesperadamente, parece que esta es la corriente limitante que puede dar un pin del microcontrolador. Si me equivoco, corrígeme.

En cualquier caso, el video de YouTube no fue engañado. De hecho, puede controlar este motor sin ningún controlador .

recomendaciones

Estudiamos en detalle los motores paso a paso bipolares en miniatura, su diseño y cómo controlarlos, para usar en nuestras propias aplicaciones.

1. El motor paso a paso bipolar en miniatura con un rotor de imán permanente es realmente en miniatura.

Sus características principales:

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

2. El motor paso a paso en miniatura puede ser controlado por cualquier controlador adecuado para trabajar con motores paso a paso bipolares, solo necesita seleccionar los parámetros de corriente del devanado.

3. El uso de un controlador especializado TMC2208 es un tema controvertido, ya que el motor no admite los micropasos, aunque las transiciones entre los pasos se realizan de manera más fluida.

4. Es posible conectar un motor paso a paso directamente a los puertos del microcontrolador. Pero esto es solo dentro del marco del experimento, ya que el par en este caso es muy insignificante, e incluso una corriente pequeña no permite que se tomen medidas a alta velocidad.

La próxima vez te diré por qué necesitábamos motores paso a paso tan pequeños.

Aprendiendo un Mini Motor Paso a Paso

Conocido

Experimento No. 1. L293D + ATtiny44

Modo paso completo Fase única

Modo paso completo Dos fases

Experimento número 2. TMC2208 + ATtiny44

Experimento número 3. ATtiny44 driver

Deja de lado todas las precauciones

recomendaciones

More articles: