Get best of the week

Einen Mini-Schrittmotor lernen

Schrittmotoren sind in der modernen Industrie und in hausgemachten Produkten weit verbreitet. Sie werden dort eingesetzt, wo es notwendig ist, die Genauigkeit der Positionierung mechanischer Komponenten sicherzustellen, ohne auf Rückkopplungen und genaue Messungen zurückgreifen zu müssen.

Heute möchte ich über eine spezielle Art von Schrittmotoren sprechen - Miniatur-Schrittmotoren, die beim Aufbau optischer Systeme verwendet werden. Wir werden uns ihr Gerät genauer ansehen und wie man so kleine Motoren steuert.



Ein Schrittmotor ist ein bürstenloser (bürstenloser) Elektromotor mit mehreren Wicklungen (Phasen) am Stator und Magneten (oft permanent) am Rotor. Durch Anlegen einer Spannung an die Statorwicklungen können wir die Position des Rotors festlegen, und durch Anlegen einer Spannung an die Wicklungen können wir nacheinander die Bewegung des Rotors von einer Position zur anderen erhalten (Schritt), und dieser Schritt hat einen festen Winkelwert.

Wir werden nicht auf die Betrachtung jedes Schrittmotortyps eingehen. Im Netzwerk und zum Beispiel hier wurde viel darüber geschrieben .

Ich möchte über eine spezielle Art von Schrittmotoren sprechen - Miniatur-Schrittmotoren, die beim Aufbau optischer Systeme verwendet werden. Diese Kinder stehen zum Verkauf. Im Netzwerk, insbesondere im russischsprachigen Raum, gibt es jedoch nur sehr wenige Informationen zu solchen Motoren. Wenn ich sie in meinem Projekt verwenden musste, musste ich daher ziemlich nach Informationen suchen und ein paar Experimente durchführen.

Ich werde die Ergebnisse meiner Suchen und Experimente in diesem Artikel teilen.

Wir werden das Management solcher kleinen Motoren betrachten, nämlich:

  • Treiber L293D + Mikrocontroller ATtiny44;
  • TMC2208-Treiber + ATtiny44-Mikrocontroller;
  • Mikrocontroller ATtiny44 (ohne Treiber).

Eigentlich kann hier nur der letzte Punkt Fragen aufwerfen. Glauben Sie mir, ich war auch überrascht, als ich auf einen Videoclip stieß ( hier ist er ), in dem der Typ den Schrittmotor einfach aufnimmt und direkt an die Stifte des Mikrocontrollers hakt! Aber lassen Sie uns über alles in Ordnung sprechen.

Bekanntschaft


Zunächst ein kleiner Blick auf das Aussehen unseres Helden:



Er ist wirklich sehr klein! Nach dem Smart Book Petrenko S.F.
"Piezoelektrische Motoren in der Instrumentierung", kleinere elektromagnetische Motoren, sind im Prinzip unmöglich zu erzeugen ... das heißt, es ist möglich, aber mit einer Verringerung des Durchmessers des Drahtes, aus dem die Wicklungen hergestellt werden, wird immer mehr Energie als Wärme an die Umgebung abgegeben, was zu einer Verringerung des Motorwirkungsgrads und der Leistung führt ihre Verwendung ist irrational.

Bemerkenswert ist, dass die Welle sehr kurz ist und eine spezielle Nut zum Einbau des Zahnrads oder Hebels aufweist.

Deutlich sichtbar sind zwei Wicklungen, die sogar mit einer Isolierung in verschiedenen Farben bedeckt sind. Unser Motor gehört also höchstwahrscheinlich zur Klasse der bipolaren Schrittmotoren.
Mal sehen, wie es funktioniert:



Ich denke, unsere Bekanntschaft mit diesen Motoren wird nicht vollständig sein, wenn wir nicht sehen, was sich darin befindet. Es ist immer interessant, in den Mechanismus zu schauen! Etwa nicht?

Eigentlich haben wir nichts Ungewöhnliches gesehen. Der Rotor ist magnetisiert. Es gibt nirgendwo Lager, alles ist auf den Buchsen. Die Hinterradnabe wird in das Motorgehäuse gedrückt. Die Front ist durch nichts fixiert. Interessanterweise wurde der Motorkörper durch Punktschweißen zusammengebaut. Also musste die vordere Abdeckung geschnitten werden.

Nun wenden wir uns dem Thema Verbindung und ihren elektrischen Eigenschaften zu.

Stellen Sie sicher, dass er bipolar ist, indem Sie die Wicklungen klingeln. Wirklich bipolar, genau wie auf dem Bild oben. Der Wicklungswiderstand beträgt ca. 26 Ohm , obwohl der Verkäufer 14 Ohm angegeben hat.
Die Beschreibung besagt, dass die Versorgungsspannung 5V beträgt . Obwohl wir alle wissen, dass für einen Schrittmotor der Strom, den seine Wicklungen verbrauchen, wichtig ist.
Wir versuchen uns zu verbinden.

Versuch Nr. 1. L293D + ATtiny44


Wie wir wissen, ist es zur Steuerung eines bipolaren Schrittmotors erforderlich, nicht nur die beiden Wicklungen in der gewünschten Reihenfolge mit Spannung zu versorgen, sondern auch die Richtung des Stroms in diesen Wicklungen zu ändern und dies unabhängig voneinander zu tun. Hierzu benötigt jede Wicklung eine eigene H-Brücke. Um ihn nicht von Transistoren abzuhalten, wurde ein fertiger L293D-Chip genommen. Ein weiterer Vorteil: Der Chip verfügt über spezielle Pins Enable1 und Enable2, die jede Brücke ein- und ausschalten. Sie können verwendet werden, um ein PWM-Signal bereitzustellen, so dass es möglich ist, die Versorgungsspannung jeder Brücke zu steuern. Warum dies erforderlich sein kann, werden wir weiter sehen.

Darüber hinaus kann der L293D Spannungen bis zu 36 V umschalten und bis zu 1,2 A pro Kanal ausgeben, was ausreichen sollte, um die Wicklungen unseres Motors anzutreiben.

Das Diagramm:



Die L293D-Steuereingänge sind mit den OC0A- und OC0B-Ausgängen verbunden, sodass wir in Zukunft ein PWM-Signal an sie senden können.

Wir werden den Controller durch den In-Circuit-Programmierer flashen (in der Abbildung nicht gezeigt).
So sieht die zusammengebaute Schaltung auf einem Steckbrett aus:



Und so befindet sich unser



Testpilot : Jetzt können Sie mit dem Experimentieren beginnen.

Wir berechnen den Strom, der durch die Motorwicklungen fließt, wenn diese an eine Spannung von 5 V angeschlossen sind:

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

Sehr klein. Ich frage mich, wie lange er einen solchen Strom halten und nicht überhitzen kann.

Wir nehmen ein Amperemeter und ein Voltmeter in den Stromkreis einer der Wicklungen auf und messen die entsprechenden Werte, wenn diese Wicklung über den Treiber mit Strom versorgt wird.

Wenn die Spannung an der 2,56-V- Wicklung abfällt, zeigt das Amperemeter einen Strom von 150 mA an , und es ist deutlich zu erkennen, wie die Stärke des Stroms während des Erhitzens der Wicklungen zu fallen beginnt. Es ist zu beachten, dass es nicht so heiß ist.

Nachdem Sie sichergestellt haben, dass die 5-V-Spannung für den Motor nicht gefährlich ist, versuchen Sie, sie in verschiedene Richtungen zu drehen. Und jetzt ein paar Worte zu den Betriebsarten des Schrittmotors.

Das ist ziemlich gut , sagt hier .

Wir werden nicht wiederholen, aber denken Sie daran, dass ein Schrittmotor in drei Modi arbeiten kann:

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

Versuchen wir, die ersten beiden Modi auf dem L293D-Chip zu implementieren, und für den Mikroschrittmodus lassen wir einen speziellen Treiber aus dem zweiten Experiment.

Der Quellcode des Programms lautet wie folgt:

WinAVR-Quellcode
#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);
		  
    } 

}


Vollschrittmodus. Einzelphase



Der Motor benötigt 16 Schritte pro Umdrehung. Darüber hinaus haben die Schritte für die beiden Phasen nicht den gleichen Winkelwert. Ich weiß nicht, womit es verbunden ist. Vielleicht ist das Design des Motors das?

Schauen wir uns die maximale Häufigkeit von Schritten an, die er in diesem Modus ausführen kann, ohne sie zu verpassen.

Die minimale Verzögerung zwischen den Schritten beträgt 2 ms, was 500 Schritte / Sekunde bedeutet. Nicht schlecht, es ist 31 U / min = 1850 U / min.

Vollschrittmodus. Zwei Phasen



Bitte beachten Sie, dass in diesem Fall die Schritte reibungsloser und gleich groß sind (in jedem Fall mehr gleich als im vorherigen Fall).

In diesem Fall werden natürlich zwei Wicklungen gleichzeitig erregt und die Wärmeübertragung nimmt zu. Nach ein paar Sekunden heizt sich der Motor ziemlich stark auf, so dass ich das Experiment abgebrochen habe.

Was ist mit der maximalen Häufigkeit von Schritten? 500 Schritte / Sekunde; 31 U / min = 1875 U / min.
Es muss gesagt werden, dass es für einen Schrittmotor ziemlich flink ist. Dies ist auf die geringe Anzahl von Magnetpolen am Rotor zurückzuführen.

Wir machen weiter ...

Versuch Nr. 2. TMC2208 + ATtiny44


TMC2208 ist der Name eines Treiberchips zur Steuerung von bipolaren Schrittmotoren, ein darauf basierendes Modul, das auch für die Installation in hausgemachten (und nicht nur) 3D-Druckern hergestellt wird und ein einheitliches Pin-Layout aufweist.
Viel und klar über dieses Modul hier gesagt .

Im Internet wurde viel darüber geschrieben, wie man es in seinem 3D-Drucker installiert, aber wir sind daran interessiert, wie man das Modul an den Mikrocontroller anschließt. Lassen Sie uns also verstehen.

Die Eigenschaften des Chips sind beeindruckend (nur beeindruckbare Personen):

  • Versorgungsspannung des logischen Teils: 3-5V;
  • Motorversorgungsspannung 5,5-36 V;
  • Spitzenstrom 2A;
  • Einstellen des maximalen Motorstroms;
  • Unterstützung der UART-Schnittstelle zum Verwalten und Konfigurieren interner Register;
  • automatische Abschaltung;
  • Unterstützung für den Mikroschrittmodus der Motorsteuerung bis zu 1/16 Schritt.



Es ist sehr einfach zu verwalten, tatsächlich benötigen Sie nur zwei Pins des Mikrocontrollers. Einer ist mit DIR verbunden - wir geben die Drehrichtung des Motors an, der andere ist mit STEP verbunden - wenn ein Impuls angelegt wird, führt die Mikroschaltung die erforderlichen Manipulationen mit Strömen und Spannungen an den Motorwicklungen durch und dauert einen Schritt.

Das Anschlussdiagramm sieht folgendermaßen aus:



Zusätzlich habe ich den EN-Pin verwendet, um den Motor auszuschalten und die Wicklungen lange Zeit nicht unter Spannung zu halten.

WinAVR-Quellcode
#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);
	
	   
	} 

}


Bevor Sie alles starten, müssen Sie das Modul vorkonfigurieren. Stellen Sie zunächst den gewünschten Mikroschrittmodus ein. Zweitens stellen Sie den gewünschten maximalen Motorstrom ein.

Mit einem Mikroschritt ist alles einfach. Verantwortlich dafür sind die Pins MS1 und MS2.



Ich stelle fest, dass die Mikroschaltung die Spannung nicht schrittweise ändert, sondern „reibungslos“. Da die Mikroschaltung jedoch digital ist, ist der Ausgang kein glattes Signal, sondern ein Signal mit einem kleinen Schritt. Gemäß der Dokumentation wird jeder Schritt in 256 Mikroschritte unterteilt. Dies wurde durchgeführt, um die Laufruhe zu erhöhen, das Geräusch des Motors zu reduzieren und theoretisch nicht zuzulassen, dass die Struktur, mit der es verschraubt ist, in Resonanz eintritt. Kurz gesagt, alles, um den 3D-Drucker leiser zu machen.

Um den Motorstrom einzustellen, muss die Spannung am Kontakt Vref gemessen werden, die in der Abbildung angegeben ist. Der Spannungswert kann mit einem Potentiometer neben dem Kontakt geändert werden. Die Spannung am Kontakt ist proportional zum Strom des Motors und die Abhängigkeit hat die folgende Form:

Vref = I * 1,44;

Unser Motor benötigt ca. 150mA, da Vref = 0.216V . Wir installieren ...

Es versteht sich, dass eine Erhöhung des Stroms die Mikroschaltung durch Erhöhen der Spannung über der Wicklung liefert. Daher müssen Sie sicherstellen, dass diese Spannung ausreicht. Aber ich glaube, 5 V sollten für diesen kleinen Motor ausreichen.

Wir werden den Betrieb des Motors mit verschiedenen Mikroschrittmodi testen und sehen, was passiert (die Pause zwischen den Mikroschritten beträgt 10 ms):


Sie können feststellen, dass die Bewegungen des Motors ruhiger geworden sind (im Vergleich zum vorherigen Experiment), die charakteristischen 16 Schritte jedoch immer noch recht deutlich beobachtet werden. Nun ... anscheinend ist dies ein Merkmal von Schrittmotoren mit einem Permanentmagnetrotor .
Es ist auch zu beachten, dass sich der Motor in diesem Modus fast so stark erwärmt wie in einem Vollschrittmodus mit zwei Phasen. Es ist verständlich, dass die Wicklungen ständig mit Strom versorgt werden und kontinuierlich Wärme erzeugt wird.

Ich glaube, dass für solche Motoren die Verwendung eines solchen Treibers und in der Tat Mikroschrittmodi nicht sehr ratsam ist.

Versuch Nr. 3. ATtiny44 Treiber


Kehren wir kurz zum ersten Experiment zurück und erinnern uns, dass die Eingänge EN1 und EN2 des Treiberchips mit den Pins OC0A und OC0B des Mikrocontrollers verbunden sind. Dies bedeutet, dass wir dort ein mit dem TIMER0-Timer erzeugtes PWM-Signal senden und so die an die Motorwicklungen angelegte Spannung ändern und den durch sie fließenden Strom entsprechend regeln können.

Laut Datenblatt des ATtiny44-Mikrocontrollers beträgt der maximale Strom, den ein Pin liefern kann, nur 40 mA. Darüber hinaus ist nicht angegeben, für welche Art von Strom (pulsierend oder konstant) diese Eigenschaft ist. Es ist einfach da und es ist so ... Ich

muss sagen, dass ich seit mehr als 7 Jahren mit ATMEL-Mikrocontrollern vertraut bin. Und ich hatte nie den Wunsch, diese Zeile aus dem Datenblatt zu überprüfen.



Vielleicht ist der Hersteller nur sicher und kann tatsächlich mehr abgeben, oder vielleicht ist es wirklich das Maximum, das einen Stift geben kann.

Wir werden es herausfinden. Aber zuerst müssen Sie herausfinden, bei welchem ​​Mindeststrom sich der Motor im Allgemeinen drehen kann.

Mit der Schaltung aus dem ersten Experiment stellen wir den Wert des Stroms durch die Wicklungen auf 40 mA ein. Wir starten im Vollschrittmodus mit zwei Phasen (da das Drehmoment höher sein wird):

Ausgezeichnet! Bei 40mA startete der Motor erfolgreich! Der für den stabilen Betrieb des Motors erforderliche Mindestwert des Wicklungsstroms wurde ebenfalls ermittelt und beträgt 30 mA.

Natürlich wird das Drehmoment viel geringer sein, aber die Tatsache, dass wir es geschafft haben, den Motor mit einem so geringen Stromverbrauch zu starten, ist für uns wichtig.

Das Anschlussdiagramm des Schrittmotors zum Mikrocontroller lautet wie folgt:



Da jeder Pin des Mikrocontrollers als Halbbrücke fungiert (er kann den Ausgang des Mikroschaltkreises entweder auf Vcc oder GND umschalten), benötigen wir zur Steuerung des bipolaren Schrittmotors 4 Pins des Mikrocontrollers.

Programmcode:

WinAVR-Quellcode
#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);
		
	
	   
	} 

}


Lassen Sie mich ein wenig erklären, wie dieses Programm funktioniert. Dies ist ein modifizierter Code aus dem ersten Experiment. Wie oben erwähnt, wird ein 8-Bit-TIMER0 verwendet, um ein PWM-Signal an den Ausgängen OC0A und OC0B zu erzeugen. Der Timer wird mit einem Prescaler von 8 auf den FastPWM-Modus eingestellt (die Signalfrequenz bei 8 MHz des Takts des Mikrocontrollers beträgt 3906 Hz).

Um die Polarität der Signale an den Wicklungen zu ändern, wird der Mikrocontroller-Pin von Vcc auf GND umgeschaltet, indem das entsprechende Bit im PORTx-Register geändert und das PWM-Tastverhältnis durch Schreiben von Werten in die Register OCR0A und OCR0B geändert wird (die Werte wurden experimentell ausgewählt).

Und so:


Ein im ersten Jahr des Instituts absolvierter Schaltungskurs legt nahe, dass das Multimeter den Effektivwert der Spannung und des Stroms im Motor anzeigt.

Der Schrittmotor dreht sich ohne Treiber von den Stiften des Mikrocontrollers!

Aber hier gehen wir zumindest nicht über die Fähigkeiten des Mikrocontrollers hinaus, wie in der Dokumentation beschrieben. In diesem Modus können der Mikrocontroller und der Motor lange arbeiten. In der Tat dauerte das Experiment 20 Minuten. Während dieser Zeit gab es keine Sprungschritte, kein Zurücksetzen der Steuerung oder Überhitzung (weder der Motor noch die Steuerung).

Legen Sie alle Vorsichtsmaßnahmen beiseite


Wir entfernen die PWM aus dem Experiment und steuern die Pins des Mikrocontrollers direkt mithilfe der PORTx-Register. Mal sehen, was danach mit dem Mikrocontroller passiert.

Es funktioniert ... mit einem maximalen Strom von 51 mA ... Nun ... unerwartet scheint es, dass dies der maximale Strom ist, der einen Pin des Mikrocontrollers ergeben kann? Wenn ich falsch liege, korrigiere mich.

In jedem Fall wurde das Video von YouTube nicht getäuscht. In der Tat können Sie diesen Motor ohne Treiber steuern .

Ergebnisse


Wir haben uns eingehend mit bipolaren Miniatur-Schrittmotoren, ihrem Design und ihrer Steuerung für den Einsatz in unseren eigenen Anwendungen befasst.

1. Der Miniatur-Bipolar-Schrittmotor mit einem Permanentmagnet-Rotor ist wirklich Miniatur.

Seine Hauptmerkmale:

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

2. Der Miniatur-Schrittmotor kann von allen Treibern gesteuert werden, die für die Arbeit mit bipolaren Schrittmotoren geeignet sind. Sie müssen nur die Wicklungsstromparameter auswählen.

3. Die Verwendung eines speziellen TMC2208-Treibers ist ein kontroverses Thema, da der Mikroschrittmodus von der Engine selbst nicht unterstützt wird, obwohl Übergänge zwischen Schritten reibungsloser ausgeführt werden.

4. Es ist möglich, einen Schrittmotor direkt an die Anschlüsse des Mikrocontrollers anzuschließen. Dies ist jedoch nur im Rahmen des Experiments möglich, da das Drehmoment in diesem Fall sehr unbedeutend ist und selbst ein kleiner Strom keine Schritte mit hoher Geschwindigkeit zulässt.

Nächstes Mal werde ich Ihnen sagen, warum wir so kleine Schrittmotoren brauchten.

More articles:


All Articles