1.3.3 Schrittmotor¶
Einführung¶
Schrittmotoren können aufgrund ihres einzigartigen Designs ohne Rückkopplungsmechanismen mit hoher Genauigkeit gesteuert werden. Die Welle eines Schrittmachers, der mit einer Reihe von Magneten montiert ist, wird von einer Reihe elektromagnetischer Spulen gesteuert, die in einer bestimmten Reihenfolge positiv und negativ geladen werden und diese in kleinen „Schritten“ präzise vorwärts oder rückwärts bewegen.
Komponenten¶
Prinzip¶
Schrittmotor
Es gibt zwei Typen von Steppern, Unipolare und Bipolare, und es ist sehr wichtig zu wissen, mit welchem Typ Sie arbeiten. In diesem Experiment verwenden wir einen unipolaren Stepper.
Der Schrittmotor ist ein Vierphasenmotor, der eine Gleichstromversorgung mit Unipolarität verwendet. Solange Sie alle Phasenwicklungen des Motors durch eine geeignete Zeitfolge elektrifizieren, können Sie ihn Schritt für Schritt drehen lassen. Das schematische Diagramm eines vierphasigen reaktiven Schrittmotors:
In der Abbildung befindet sich in der Mitte des Motors ein Rotor - ein zahnradförmiger Permanentmagnet. Um den Rotor herum sind 0 bis 5 Zähne. Dann weiter draußen gibt es 8 Magnetpole, wobei jeweils zwei gegenüberliegende durch Spulenwicklung verbunden sind. Sie bilden also vier Paare von A nach D, was als Phase bezeichnet wird. Es verfügt über vier Anschlusskabel, die mit den Schaltern SA, SB, SC und SD verbunden werden können. Daher sind die vier Phasen in der Schaltung parallel und die zwei Magnetpole in einer Phase sind in Reihe geschaltet.
So funktioniert ein 4-Phasen-Schrittmotor:
Wenn der Schalter SB eingeschaltet ist, sind die Schalter SA, SC und SD ausgeschaltet, und die B-Phasen-Magnetpole sind auf die Zähne 0 und 3 des Rotors ausgerichtet. Gleichzeitig erzeugen Zahn 1 und 4 versetzte Zähne mit C- und D-Phasenpolen. Zahn 2 und 5 erzeugen versetzte Zähne mit D- und A-Phasenpolen. Wenn der Schalter SC eingeschaltet ist, die Schalter SB, SA und SD ausgeschaltet sind, dreht sich der Rotor unter dem Magnetfeld der C-Phasenwicklung und dem zwischen Zahn 1 und 4. Dann richten sich Zahn 1 und 4 an den Magnetpolen der C-Phasenwicklung aus. Während Zahn 0 und 3 versetzte Zähne mit A- und B-Phasenpolen erzeugen, erzeugen Zahn 2 und 5 versetzte Zähne mit den Magnetpolen von A- und D-Phasenpolen. Die ähnliche Situation geht weiter und weiter. Schalten Sie die Phasen A, B, C und D nacheinander ein, und der Rotor dreht sich in der Reihenfolge A, B, C und D.
Der Vierphasen-Schrittmotor verfügt über drei Betriebsarten: einfach vierstufig, doppelt vierstufig und achtstufig. Der Schrittwinkel für den einzelnen vierstufigen und den doppelten vierstufigen ist gleich, aber das Antriebsmoment für den einzelnen vierstufigen ist kleiner. Der Schrittwinkel des Achtstufens ist halb so groß wie der des Einzel-Vier-Stufen- und des Doppel-Vier-Stufen-Winkels. Somit kann der achtstufige Betriebsmodus ein hohes Antriebsmoment beibehalten und die Steuergenauigkeit verbessern.
Der von uns verwendete Stator des Schrittmotors hat 32 Magnetpole, sodass ein Kreis 32 Schritte benötigt. Die Abtriebswelle des Schrittmotors ist mit einem Untersetzungsgetriebesatz verbunden, und das Untersetzungsverhältnis beträgt 1/64. Die endgültige Abtriebswelle dreht also einen Kreis, der einen Schritt von 32 * 64 = 2048 erfordert.
ULN2003
Um den Motor in die Schaltung einzubringen, muss eine Treiberplatine verwendet werden. Stepper Motor Driver-ULN2003 ist eine 7-Kanal-Inverterschaltung. Das heißt, wenn der Eingangspin auf High-Pegel ist, ist der Ausgangspin von ULN2003 auf Low-Pegel und umgekehrt. Wenn wir IN1 High-Pegel und IN2, IN3 und IN4 Low-Pegel liefern, dann ist das Ausgangsende OUT1 auf Low-Pegel und alle anderen Ausgangsenden auf High-Pegel. Die interne Struktur des Chips ist wie folgt dargestellt.
Der Schrittmotortreiber, der aus dem ULN2003-Chip und 4 LEDs besteht, ist wie folgt dargestellt. Auf der Platine fungieren IN1, IN2, IN3 und IN4 als Eingang und die vier LEDs A, B, C, D sind die Anzeigen des Eingangspins. Zusätzlich sind OUT1, OUT2, OUT3 und OUT4 mit SA, SB, SC und SD am Schrittmotortreiber verbunden. Wenn der Wert von IN1 auf einen hohen Niveau eingestellt ist, leuchtet A auf; Schalter SA ist eingeschaltet und der Schrittmotor dreht sich einen Schritt. Der ähnliche Fall wiederholt sich immer weiter. Geben Sie dem Schrittmotor daher einfach eine bestimmte Zeitfolge, er dreht sich Schritt für Schritt. Der ULN2003 wird hier verwendet, um bestimmte Zeitabläufe für den Schrittmotor bereitzustellen.
Schematische Darstellung¶
Experimentelle Verfahren¶
Schritt 1: Bauen Sie die Schaltung auf.
Für Benutzer in C-Sprache¶
Schritt 2: Gehen Sie zum Ordner des Codes.
cd /home/pi/davinci-kit-for-raspberry-pi/c/1.3.3/
Schritt 3: Kompilieren Sie den Code.
gcc 1.3.3_StepperMotor.c -lwiringPi
Schritt 4: Führen Sie die ausführbare Datei aus.
sudo ./a.out
Während der Code läuft, dreht sich der Schrittmotor entsprechend Ihrer Eingabe ‚a‘ oder ‚c‘ im oder gegen den Uhrzeigersinn.
Code
#include <stdio.h>
#include <wiringPi.h>
const int motorPin[] = {1, 4, 5, 6};
int rolePerMinute = 15;
int stepsPerRevolution = 2048;
int stepSpeed = 0;
void rotary(char direction){
if(direction == 'c'){
for(int j=0;j<4;j++){
for(int i=0;i<4;i++)
{digitalWrite(motorPin[i],0x99>>j & (0x08>>i));}
delayMicroseconds(stepSpeed);
}
}
else if(direction =='a'){
for(int j=0;j<4;j++){
for(int i=0;i<4;i++)
{digitalWrite(motorPin[i],0x99<<j & (0x80>>i));}
delayMicroseconds(stepSpeed);
}
}
}
void loop()
{
char direction = '0';
while (1)
{
printf("select motor direction a=anticlockwise, c=clockwise: ");
delay(100);
direction=getchar();
if (direction == 'c')
{
printf("motor running clockwise\n");
delay(100);
break;
}
else if (direction == 'a')
{
printf("motor running anti-clockwise\n");
delay(100);
break;
}
else
{
printf("input error, please try again!\n");
delay(100);
}
}
while(1)
{
rotary(direction);
}
}
void main(void)
{
if (wiringPiSetup() == -1)
{
printf("setup wiringPi failed !");
return;
}
for (int i = 0; i < 4; i++)
{
pinMode(motorPin[i], OUTPUT);
}
stepSpeed = (60000000 / rolePerMinute) / stepsPerRevolution;
loop();
}
Code Erklärung
int rolePerMinute = 15;
int stepsPerRevolution = 2048;
int stepSpeed = 0;
rolePerMinute: Umdrehungen pro Minute sollte die Drehzahl des in diesem Kit verwendeten Schrittmotors 0 bis 17 betragen.
stepPerRevolution: Die Anzahl der Schritte für jede Umdrehung und der in diesem Kit verwendete Schrittmotor benötigen 2048 Schritte pro Umdrehung.
stepSpeed: Die für jeden Schritt verwendete Zeit. In main() weisen wir ihnen die folgenden Werte zu: 「(60000000 / rolePerMinute) / stepPerRevolution」 (60.000.000 us = 1 Minute)
void loop()
{
char direction = '0';
while (1)
{
printf("select motor direction a=anticlockwise, c=clockwise: ");
direction=getchar();
if (direction == 'c')
{
printf("motor running clockwise\n");
break;
}
else if (direction == 'a')
{
printf("motor running anti-clockwise\n");
break;
}
else
{
printf("input error, please try again!\n");
}
}
while(1)
{
rotary(direction);
}
}
Die Funktion loop() ist grob in zwei Teile unterteilt (zwischen zwei while(1) ):
Der erste Teil besteht darin, den Schlüsselwert zu erhalten. Wenn ‚a‘ oder ‚c‘ erhalten wird, verlassen Sie die Schleife und stoppen Sie die Eingabe.
Der zweite Teil ruft rotary(direction) auf, um den Schrittmotor laufen zu lassen.
void rotary(char direction){
if(direction == 'c'){
for(int j=0;j<4;j++){
for(int i=0;i<4;i++)
{digitalWrite(motorPin[i],0x99>>j & (0x08>>i));}
delayMicroseconds(stepSpeed);
}
}
else if(direction =='a'){
for(int j=0;j<4;j++){
for(int i=0;i<4;i++)
{digitalWrite(motorPin[i],0x99<<j & (0x80>>i));}
delayMicroseconds(stepSpeed);
}
}
}
Damit sich der Schrittmotor im Uhrzeigersinn dreht, sollte der Füllstandsstatus von motorPin in der folgenden Tabelle angezeigt werden:
Daher wird das potentielle Schreiben von MotorPin unter Verwendung einer zweischichtigen for-Schleife implementiert.
In Schritt 1 ist j = 0, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (10011001 & 00001000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (10011001 & 00000100 = 0)
motorPin[2] wird in der niedrigen Ebene geschrieben (10011001 & 00000010 = 0)
motorPin[3] wird in der hohen Ebene geschrieben (10011001 & 00000001 = 1)
In Schritt 2 ist j = 1, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (01001100 & 00001000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (01001100 & 00000100 = 1)
usw.
Damit sich der Schrittmotor gegen den Uhrzeigersinn dreht, wird der Füllstandsstatus von motorPin in der folgenden Tabelle angezeigt.
In Schritt 1 ist j = 0, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (10011001 & 10000000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (10011001 & 01000000 = 0)
In Schritt 2 ist ， j = 1, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (00110010 & 10000000 = 0)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (00110010 & 01000000 = 0)
Für Python-Sprachbenutzer¶
Schritt 2: Gehen Sie zum Ordner des Codes.
cd /home/pi/davinci-kit-for-raspberry-pi/python/
Schritt 3: Führen Sie die ausführbare Datei aus.
sudo python3 1.3.3_StepperMotor.py
Während der Code läuft, dreht sich der Schrittmotor abhängig von Ihrer Eingabe ‚a‘ oder ‚a‘ im oder gegen den Uhrzeigersinn.
Code
Bemerkung
Sie können den folgenden Code Ändern/Zurücksetzen/Kopieren/Ausführen/Stoppen . Zuvor müssen Sie jedoch zu einem Quellcodepfad wie davinci-kit-for-raspberry-pi/python gehen.
import RPi.GPIO as GPIO
from time import sleep
motorPin = (18,23,24,25)
rolePerMinute =15
stepsPerRevolution = 2048
stepSpeed = (60/rolePerMinute)/stepsPerRevolution
def setup():
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
for i in motorPin:
GPIO.setup(i, GPIO.OUT)
def rotary(direction):
if(direction == 'c'):
for j in range(4):
for i in range(4):
GPIO.output(motorPin[i],0x99>>j & (0x08>>i))
sleep(stepSpeed)
elif(direction == 'a'):
for j in range(4):
for i in range(4):
GPIO.output(motorPin[i],0x99<<j & (0x80>>i))
sleep(stepSpeed)
def loop():
while True:
direction = input('select motor direction a=anticlockwise, c=clockwise: ')
if(direction == 'c'):
print('motor running clockwise\n')
break
elif(direction == 'a'):
print('motor running anti-clockwise\n')
break
else:
print('input error, please try again!')
while True:
rotary(direction)
def destroy():
GPIO.cleanup()
if __name__ == '__main__':
setup()
try:
loop()
except KeyboardInterrupt:
destroy()
Code Erklärung
rolePerMinute =15
stepsPerRevolution = 2048
stepSpeed = (60/rolePerMinute)/stepsPerRevolution
rolePerMinute: Umdrehungen pro Minute sollte die Drehzahl des in diesem Kit verwendeten Schrittmotors 0 bis 17 betragen.
stepPerRevolution: Die Anzahl der Schritte für jede Umdrehung und der in diesem Kit verwendete Schrittmotor benötigen 2048 Schritte pro Umdrehung.
stepSpeed: Die Zeit, die für jeden Schritt verwendet wird, und wir weisen ihnen die Werte zu: 「(60 / rolePerMinute) / stepPerRevolution」 (60s = 1minute).
def loop():
while True:
direction = input('select motor direction a=anticlockwise, c=clockwise: ')
if(direction == 'c'):
print('motor running clockwise\n')
break
elif(direction == 'a'):
print('motor running anti-clockwise\n')
break
else:
print('input error, please try again!')
while True:
rotary(direction)
Die Funktion loop() ist grob in zwei Teile unterteilt (in zwei Teilen, while(1) ):
Der erste Teil besteht darin, den Schlüsselwert zu erhalten. Wenn ‚a‘ oder ‚c‘ erhalten wird, verlassen Sie die Schleife und stoppen Sie die Eingabe.
Der zweite Teil ruft rotary(direction) auf, um den Schrittmotor laufen zu lassen.
def rotary(direction):
if(direction == 'c'):
for j in range(4):
for i in range(4):
GPIO.output(motorPin[i],0x99>>j & (0x08>>i))
sleep(stepSpeed)
elif(direction == 'a'):
for j in range(4):
for i in range(4):
GPIO.output(motorPin[i],0x99<<j & (0x80>>i))
sleep(stepSpeed)
Um den Schrittmotor im Uhrzeigersinn drehen zu lassen, wird der Niveau status von motorPin in der folgenden Tabelle angezeigt:
Daher wird das potentielle Schreiben von MotorPin unter Verwendung einer zweischichtigen for-Schleife implementiert.
In Schritt 1 ist j = 0, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (10011001 & 00001000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (10011001 & 00000100 = 0)
motorPin[2] wird in der niedrigen Ebene geschrieben (10011001 & 00000010 = 0)
motorPin[3] wird in der hohen Ebene geschrieben (10011001 & 00000001 = 1)
In Schritt 2 ist j = 1, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (01001100 & 00001000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (01001100 & 00000100 = 1)
usw
Um den Schrittmotor gegen den Uhrzeigersinn drehen zu lassen, wird der Füllstandsstatus von motorPin in der folgenden Tabelle angezeigt.
In Schritt 1 ist j = 0, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (10011001 & 10000000 = 1)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (10011001 & 01000000 = 0)
In Schritt 2 ist j = 1, i = 0 ~ 4.
motorPin[0] wird in der hohen Ebene geschrieben (00110010 & 10000000 = 0)
motorPin[1] wird auf dem niedrigen Niveau geschrieben (00110010 & 01000000 = 0)
usw.
Phänomen Bild¶
