Get best of the week

Aprendendo um Mini Motor de Passo

Os motores de passo são amplamente utilizados na indústria moderna e em produtos caseiros. Eles são usados ​​onde é necessário garantir a precisão do posicionamento dos componentes mecânicos, sem recorrer a feedback e medições precisas.

Hoje eu quero falar sobre um tipo especial de motores de passo - motores de passo em miniatura, que são usados ​​na construção de sistemas ópticos. Vamos dar uma olhada em seu dispositivo e em como controlar esses motores minúsculos.



Um motor de passo é um motor elétrico sem escova (sem escova) com vários enrolamentos (fases) localizados no estator e ímãs (geralmente permanentes) no rotor. Aplicando tensão nos enrolamentos do estator, podemos fixar a posição do rotor e, aplicando tensão nos enrolamentos, podemos obter sucessivamente o movimento do rotor de uma posição para outra (etapa), e essa etapa tem um valor angular fixo.

Não vamos nos debruçar sobre a consideração de cada tipo de motor de passo. Muito foi escrito sobre isso na rede e bem, por exemplo, aqui .

Quero falar sobre um tipo especial de motores de passo - motores de passo em miniatura, que são usados ​​na construção de sistemas ópticos. Essas crianças estão disponíveis para venda. Mas na rede, especialmente em língua russa, há muito pouca informação sobre esses motores. Portanto, quando eu precisava usá-los em meu projeto, tive que procurar informações e realizar algumas experiências.

Compartilharei os resultados de minhas pesquisas e experiências neste artigo.

Consideraremos o gerenciamento desses pequenos motores, a saber:

  • controlador L293D + microcontrolador ATtiny44;
  • Driver TMC2208 + microcontrolador ATtiny44;
  • microcontrolador ATtiny44 (sem driver).

Na verdade, apenas o último ponto pode causar perguntas aqui. Acredite, também fiquei surpreso quando me deparei com um videoclipe ( aqui está ), onde o cara apenas pega e conecta diretamente o motor de passo aos pinos do microcontrolador! Mas vamos falar sobre tudo em ordem.

Conhecido


Primeiro, dê uma olhada na aparência do nosso herói:



ele é realmente muito pequeno! De acordo com o livro inteligente Petrenko S.F.
"Motores piezoelétricos em instrumentação", motores eletromagnéticos menores, em princípio, é impossível criar ... isto é, é possível, mas com uma diminuição no diâmetro do fio do qual os enrolamentos são feitos, mais e mais energia é dissipada como calor no ambiente, o que leva a uma diminuição na eficiência do motor e torna seu uso é irracional.

Do notável, pode-se notar que seu eixo é muito curto e possui uma ranhura especial para a instalação da engrenagem ou alavanca.

Dois enrolamentos são claramente visíveis, que são cobertos com isolamento de cores diferentes. Portanto, nosso motor provavelmente pertence à classe dos motores de passo bipolares.
Vamos ver como funciona:



acho que nosso conhecimento desses motores não estará completo se não percebermos o que está dentro dele. É sempre interessante olhar dentro do mecanismo! Não é assim?

Na verdade, não vimos nada incomum. O rotor é magnetizado. Não há rolamentos em lugar algum, tudo está nas buchas. O cubo traseiro é pressionado na carcaça do motor. A frente não é fixa por nada. Curiosamente, o corpo do motor foi montado por solda a ponto. Então a capa da frente teve que ser cortada.

Agora nos voltamos para a questão da conexão e suas características elétricas.

Certifique-se de que ele seja bipolar tocando os enrolamentos. Realmente bipolar, como na foto acima. A resistência do enrolamento é de cerca de 26 ohms , embora o vendedor tenha indicado 14 ohms.
A descrição diz que a tensão de alimentação é de 5V . Embora todos saibamos que para um motor de passo, a corrente que seus enrolamentos consumirão é importante.
Estamos tentando nos conectar.

Experiência nº 1. L293D + ATtiny44


Como sabemos, para controlar um motor de passo bipolar, é necessário não apenas aplicar tensão aos dois enrolamentos na sequência desejada, mas também alterar a direção da corrente nesses enrolamentos e fazê-lo independentemente um do outro. Para isso, cada enrolamento precisa de sua própria ponte H. Para não cercá-lo dos transistores, um chip L293D pronto foi usado. Outra das suas vantagens - o chip possui pinos especiais Enable1 e Enable2, que ativam e desativam cada ponte. Eles podem ser usados ​​para fornecer um sinal PWM, portanto, é possível controlar a tensão de alimentação de cada ponte. Por que isso pode ser necessário, veremos mais adiante.

Além disso, o L293D pode alternar tensões de até 36V e produzir até 1,2A por canal, o que deve ser suficiente para alimentar os enrolamentos do nosso motor.

Portanto, o diagrama:



As entradas de controle L293D são conectadas às saídas OC0A e OC0B, o que nos permitirá enviar um sinal PWM para elas no futuro.

Iremos piscar o controlador através do programador em circuito (não mostrado no diagrama).
Aqui está a aparência do circuito montado em uma placa de



ensaio : E é assim que nosso



piloto de teste está localizado: Agora você pode começar a experimentar.

Calculamos a corrente que fluirá através dos enrolamentos do motor quando eles estiverem conectados a uma tensão de 5V:

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

Muito pequeno. Gostaria de saber quanto tempo ele pode aguentar uma corrente tão grande e não superaquecer.

Incluímos um amperímetro e um voltímetro no circuito de um dos enrolamentos e medimos os valores correspondentes quando a energia é fornecida a esse enrolamento através do driver.

Quando a tensão cai no enrolamento de 2,56V, o amperímetro mostra uma corrente de 150mA , e é claramente visível como a magnitude da corrente começa a cair durante o aquecimento dos enrolamentos. Note-se que não é tão quente.

Depois de se certificar de que a tensão de 5V do motor não é perigosa, tente torcer-os em direções diferentes. E agora, algumas palavras, falaremos sobre os modos de operação do motor de passo.

Isto é muito bem dito aqui .

Não repetiremos, mas lembre-se de que um motor de passo pode operar em três modos:

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

Vamos tentar implementar os dois primeiros modos no chip L293D e, no modo micro-passo, deixaremos um driver especial do segundo experimento.

O código fonte do programa é o seguinte:

Código fonte 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 passo completo. Fase única



O mecanismo dá 16 passos por rotação. Além disso, os passos para as duas fases não têm o mesmo valor angular. Não sei com o que está conectado. Talvez o design do motor seja esse?

Vejamos a frequência máxima de etapas que ele pode fornecer nesse modo sem perdê-las.

O atraso mínimo entre as etapas é de 2 ms, o que significa 500 etapas / segundo. Nada mal, são 31 rpm = 1850 rpm.

Modo passo completo. Duas fases



Observe que, neste caso, as etapas são mais suaves, têm o mesmo tamanho (em qualquer caso, mais do que no caso anterior).

Naturalmente, neste caso, dois enrolamentos são energizados simultaneamente e a transferência de calor aumenta. Depois de alguns segundos, o motor esquenta bastante, então parei o experimento.

O que com a frequência máxima de etapas? 500 etapas / segundo; 31 rpm = 1875 rpm.
Deve-se dizer que, para um motor de passo, é bastante ágil. Isto é devido ao pequeno número de pólos magnéticos no rotor.

Nós continuamos ...

Experiência número 2. TMC2208 + ATtiny44


TMC2208 é o nome de um chip de driver para controle de motores de passo bipolares, também chamado de módulo, produzido para instalação em impressoras 3D caseiras (e não apenas) e com layout de pinos unificado.
Muito e lucidamente disse sobre este módulo aqui .

Muito foi escrito na Internet sobre como instalá-lo na sua impressora 3D, mas estamos interessados ​​em como conectar o módulo ao microcontrolador, então vamos entender.

As características do chip são impressionantes (apenas pessoas impressionáveis):

  • tensão de alimentação da parte lógica: 3-5V;
  • tensão de alimentação do motor 5.5-36V;
  • corrente de pico 2A;
  • ajuste da corrente máxima do motor;
  • Suporte à interface UART para gerenciar e configurar registros internos;
  • desligamento automático;
  • suporte para o modo de micro etapas do controle do motor até 1/16 de uma etapa.



É muito simples de gerenciar, de fato, você precisa de apenas dois pinos do microcontrolador. Um está conectado ao DIR - indicamos a direção de rotação do motor, o outro está conectado ao STEP - quando um pulso é aplicado, o microcircuito realiza as manipulações necessárias com correntes e tensões nos enrolamentos do motor e dá um passo.

O diagrama de conexão ficará assim:



Além disso, usei o pino EN para desligar o motor e por um longo tempo para não manter os enrolamentos energizados.

Código fonte 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 iniciar tudo, você precisa pré-configurar o módulo. Primeiro, defina o modo microstep desejado. Em segundo lugar, defina a corrente máxima desejada do motor.

Com um microstep, tudo é simples. Os pinos MS1 e MS2 são responsáveis ​​por isso.



Observo que o microcircuito não altera a tensão passo a passo, mas o faz "suavemente", mas como o microcircuito é digital, a saída não é um sinal suave, mas um sinal com um pequeno passo, de acordo com a documentação, divide cada passo em 256 micro etapas. Isso foi feito para aumentar a suavidade da marcha, reduzir o ruído do motor e, em teoria, não deve permitir que a estrutura na qual está parafusado entre em ressonância. Em resumo, tudo para tornar a impressora 3D mais silenciosa.

Para definir a corrente do motor, é necessário medir a tensão no contato Vref, indicado na figura. O valor da tensão pode ser alterado usando um potenciômetro instalado ao lado do contato. A tensão no contato será proporcional à corrente do motor e a dependência terá a seguinte forma:

Vref = I * 1,44;

Nosso motor precisa de cerca de 150mA, porque Vref = 0,216V . Instalamos ...

Entende-se que um aumento na corrente fornece o microcircuito aumentando a tensão no enrolamento. Portanto, você precisa garantir que essa tensão seja suficiente. Mas, acredito, 5V deve ser suficiente para esse pequeno motor.

Testaremos a operação do motor com vários modos de micro passo e veremos o que acontece (a pausa entre micro passos é de 10 ms):


Você pode notar que os movimentos do motor se tornaram mais suaves (em comparação com o experimento anterior), no entanto, as 16 etapas características ainda são observadas com muita clareza. Bem ... aparentemente essa é uma característica dos motores de passo com um rotor de ímã permanente .
Também deve ser observado que o motor neste modo aquece quase tanto quanto no modo de passo completo com duas fases. É compreensível, os enrolamentos são constantemente energizados, o calor está sendo gerado continuamente.

Acredito que, para tais motores, o uso de um driver desse tipo e, na verdade, modos de micro passo, não é muito recomendável.

Experiência número 3. Driver ATtiny44


Vamos retornar brevemente ao primeiro experimento e lembrar que as entradas EN1 e EN2 do chip do driver estão conectadas aos pinos OC0A e OC0B do microcontrolador. Isso significa que podemos enviar para lá um sinal PWM gerado usando o temporizador TIMER0 e, assim, alterar a tensão aplicada aos enrolamentos do motor e regular a corrente que fluirá através deles.

De acordo com a folha de dados do microcontrolador ATtiny44, a corrente máxima que um pino pode fornecer é de apenas 40mA. Além disso, não é indicado para que tipo de corrente (pulsante ou constante) essa característica. Está aí e é assim ...

Devo dizer que estou familiarizado com os microcontroladores ATMEL há mais de 7 anos. E nunca tive o desejo de verificar esta linha na folha de dados.



Talvez o fabricante seja apenas seguro e, de fato, possa distribuir mais, ou talvez seja realmente o máximo que pode fornecer um pino.

Vamos descobrir. Mas primeiro você precisa descobrir em qual corrente mínima o motor geralmente consegue girar.

Usando o circuito do primeiro experimento, ajustamos o valor da corrente através dos enrolamentos igual a 40 mA. Começamos no modo de etapa completa com duas fases (pois o torque será maior):

Excelente! A 40mA, o mecanismo iniciou com sucesso! Também foi detectado o valor mínimo da corrente de enrolamento necessária para a operação estável do motor, e é igual a 30mA.

Obviamente, o torque será muito menor, mas o fato de termos conseguido dar partida no motor com um consumo de energia tão pequeno é importante para nós.

O diagrama de conexão do motor de passo ao microcontrolador será o seguinte:



Como cada pino do microcontrolador funciona como uma meia ponte (ele pode alternar a saída do microcircuito para Vcc ou GND), para controlar o motor de passo bipolar, precisamos de 4 pinos do microcontrolador.

Código do programa:

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

}


Deixe-me explicar um pouco como esse programa funciona. Este é um código modificado da primeira experiência. Como eu disse acima, um TIMER0 de 8 bits será usado para gerar um sinal PWM nas saídas OC0A e OC0B. O timer está definido no modo FastPWM com um pré-calibrador de 8 (a frequência do sinal a 8 MHz do relógio do microcontrolador é de 3906 Hz).

Para alterar a polaridade dos sinais nos enrolamentos, o pino do microcontrolador é alternado de Vcc para GND, alterando o bit correspondente no registro PORTx e alterando o ciclo de trabalho PWM, escrevendo valores nos registros OCR0A e OCR0B (os valores foram selecionados experimentalmente).

E entao:


Um curso de circuito realizado no primeiro ano do instituto sugere que o multímetro mostre o valor eficaz da tensão e corrente no motor.

O motor de passo gira dos pinos do microcontrolador sem drivers!

Mas aqui não vamos além das capacidades do microcontrolador, pelo menos, de acordo com o que está escrito na documentação. Nesse modo, o microcontrolador e o motor podem funcionar por um longo tempo. De fato, o experimento durou 20 minutos. Durante esse período, não houve etapas de pulo, reinicialização do controlador ou superaquecimento (nem o motor nem o controlador).

Ponha de lado todas as precauções


Removemos o PWM do experimento e controlaremos diretamente os pinos do microcontrolador usando os registradores PORTx. Vamos ver o que acontece com o microcontrolador depois disso.

Funciona ... com uma corrente máxima de 51mA ... Bem ... inesperadamente, parece que essa é a corrente máxima que pode fornecer um pino do microcontrolador? Se eu estiver errado, me corrija.

De qualquer forma, o vídeo do YouTube não foi enganado. Na verdade, você pode controlar este motor sem nenhum driver .

achados


Estudamos detalhadamente motores passo a passo bipolares em miniatura, seu design e como controlá-los, para uso em nossas próprias aplicações.

1. O motor de passo bipolar em miniatura com um rotor de ímã permanente é realmente miniatura.

Suas principais características:

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

2. O motor de passo em miniatura pode ser controlado por qualquer driver adequado para trabalhar com motores de passo bipolares; você só precisa selecionar os parâmetros da corrente de enrolamento.

3. O uso de um driver TMC2208 especializado é um problema controverso, pois o modo microstep não é suportado pelo próprio mecanismo, embora as transições entre as etapas sejam realizadas de maneira mais suave.

4. É possível conectar um motor de passo diretamente às portas do microcontrolador. Mas isso é apenas dentro da estrutura do experimento, uma vez que o torque, neste caso, é muito insignificante, e mesmo uma pequena corrente não permite que sejam tomadas medidas em alta velocidade.

Da próxima vez, vou explicar por que precisamos de pequenos motores de passo.

More articles:


All Articles