- Servomotor
- Steuerung des Servomotors mit LPC2148 PWM & ADC
- PWM- und ADC-Pins in ARM7-LPC2148
- Erforderliche Komponenten
- Schaltplan und Anschlüsse
- Programmierung des ARM7-LPC2148 für die Servomotorsteuerung
In unserem vorherigen Tutorial haben wir den Schrittmotor mit ARM7-LPC2148 verbunden. In diesem Tutorial steuern wir den Servomotor mit ARM7-LPC2148. Der Servomotor hat gegenüber dem Schrittmotor einen geringen Stromverbrauch. Ein Servomotor stoppt seinen Stromverbrauch, wenn die gewünschte Position erreicht ist, aber der Schrittmotor verbraucht kontinuierlich Strom, um die Welle in der gewünschten Position zu blockieren. Servomotoren werden aufgrund ihrer Genauigkeit und einfachen Handhabung hauptsächlich in Robotikprojekten eingesetzt.
In diesem Tutorial erfahren Sie mehr über den Servomotor und die Schnittstelle zwischen Servo und ARM7-LPC2148. Ein Potentiometer ist ebenfalls angeschlossen, um die Position der Welle des Servomotors zu variieren, und ein LCD, um den Winkelwert anzuzeigen.
Servomotor
Ein Servomotor ist eine Kombination aus Gleichstrommotor, Lageregelungssystem und Zahnrädern. Die Drehung des Servomotors wird durch Anlegen eines PWM-Signals gesteuert. Die Breite des PWM-Signals bestimmt den Drehwinkel und die Richtung des Motors. Hier werden wir SG90 Servomotor in diesem Tutorial verwenden, es ist eines der beliebtesten und billigsten. SG90 ist ein 180-Grad-Servo. Mit diesem Servo können wir also die Achse von 0-180 Grad positionieren:
- Betriebsspannung: + 5V
- Getriebetyp: Kunststoff
- Drehwinkel: 0 bis 180 Grad
- Gewicht: 9 g
- Drehmoment: 2,5 kg / cm
Bevor wir mit der Programmierung für den Servomotor beginnen können, sollten wir wissen, welche Art von Signal zur Steuerung des Servomotors gesendet werden soll. Wir sollten die MCU so programmieren, dass PWM-Signale an das Signalkabel des Servomotors gesendet werden. Im Servomotor befindet sich eine Steuerschaltung, die den Arbeitszyklus des PWM-Signals liest und die Welle der Servomotoren an der entsprechenden Stelle positioniert, wie in der folgenden Abbildung gezeigt
Der Servomotor überprüft alle 20 Millisekunden den Impuls. Passen Sie also die Impulsbreite des Signals an, um die Motorwelle zu drehen.
- 1 ms (1 Millisekunde) Impulsbreite für die Drehung des Servos um 0 Grad
- 1,5 ms Impulsbreite für Drehung um 90 Grad (neutrale Position)
- 2 ms Impulsbreite für die Drehung des Servos um 180 Grad.
Bevor Sie das Servo an ARM7-LPC2148 anschließen, können Sie Ihr Servo mit Hilfe dieser Servomotor -Testschaltung testen. Überprüfen Sie auch, wie ein Servomotor mit anderen Mikrocontrollern verbunden werden kann:
- Servomotorsteuerung mit Arduino
- Schnittstelle zwischen Servomotor und 8051-Mikrocontroller
- Servomotorsteuerung mit MATLAB
- Servomotorsteuerung mit Raspberry Pi
- Schnittstelle zwischen Servomotor und MSP430G2
- Servomotor mit STM32F103C8 verbinden
Steuerung des Servomotors mit LPC2148 PWM & ADC
Ein Servomotor kann von LPC2148 über PWM gesteuert werden. Durch die Bereitstellung eines PWM-Signals an den PWM-Pin von SERVO mit einer Periode von 20 ms und einer Frequenz von 50 Hz können wir die Welle des Servomotors um 180 Grad (-90 bis +90) positionieren.
Ein Potentiometer wird verwendet, um das Tastverhältnis des PWM-Signals zu variieren und die Welle des Servomotors zu drehen. Diese Methode wird mithilfe des ADC-Moduls in LPC2148 implementiert. Daher müssen in diesem Tutorial sowohl PWM- als auch ADC-Konzepte implementiert werden. Lesen Sie daher bitte unsere vorherigen Tutorials, um PWM und ADC in ARM7-LPC2148 zu lernen.
- Verwendung von PWM in ARM7-LPC2148
- Verwendung von ADC in ARM-LPLC2148
PWM- und ADC-Pins in ARM7-LPC2148
Das Bild unten zeigt die PWM- und ADC-Pins in LPC2148. Gelbe Kästchen kennzeichnen die (6) PWM-Stifte und schwarze Kästchen kennzeichnen die (14) ADC-Stifte.
Erforderliche Komponenten
Hardware
- ARM7-LPC2148
- LCD (16x2) Anzeigemodul
- Servomotor (SG-90)
- 3,3 V Spannungsregler
- 10k Potentiometer (2 Nr.)
- Steckbrett
- Kabel anschließen
Software
- Keil uVision5
- Flash Magic Tool
Schaltplan und Anschlüsse
Die folgende Tabelle zeigt die Verbindung zwischen Servomotor und ARM7-LPC2148:
|
SERVO PINS |
ARM7-LPC2148 |
|
ROT (+ 5V) |
+ 5V |
|
BRAUN (GND) |
GND |
|
ORANGE (PWM) |
P0.1 |
Der Pin P0.1 ist der PWM-Ausgang von LPC2148.
Die folgende Tabelle zeigt die Schaltungsverbindungen zwischen LCD und ARM7-LPC2148.
|
ARM7-LPC2148 |
LCD (16x2) |
|
P0.4 |
RS (Register Select) |
|
P0.6 |
E (Aktivieren) |
|
P0.12 |
D4 (Datenstift 4) |
|
P0.13 |
D5 (Datenstift 5) |
|
P0.14 |
D6 (Datenstift 6) |
|
P0.15 |
D7 (Datenstift 7) |
|
GND |
VSS, R / W, K. |
|
+ 5V |
VDD, A. |
Die folgende Tabelle zeigt die Verbindungen zwischen ARM7 LPC2148 und Potentiometer mit 3,3-V-Spannungsregler.
|
3,3 V Spannungsregler-IC |
Pin-Funktion |
ARM-7 LPC2148 Pin |
|
1. Linker Stift |
- Ve von GND |
GND Pin |
|
2.Centre Pin |
Geregelter + 3,3 V Ausgang |
Zum Potentiometereingang und Potentiometerausgang zu P0.28 von LPC2148 |
|
3.Rechter Stift |
+ Ve von 5V EINGANG |
+ 5V |
Zu beachtende Punkte
1. Ein Spannungsregler von 3,3 V wird hier verwendet, um den ADC-Pin (P0.28) des LPC2148 mit einem analogen Eingangswert zu versorgen. Da wir 5 V verwenden, müssen wir die Spannung mit einem Spannungsregler von 3,3 V regeln.
2. Ein Potentiometer wird verwendet, um die Spannung zwischen (0 V und 3,3 V) zu variieren und einen Analogeingang (ADC) für LPC2148 Pin P0.28 bereitzustellen
3. Der Pin P0.1 von LPC2148 liefert einen PWM-Ausgang an den Servomotor, um die Position des Motors zu steuern.
4. Entsprechend dem ADC-Wert (Analogeingang) ändert sich die Position des Servomotors von (0 auf 180 Grad) über den PWM-Ausgangspin bei P0.1 von LPC2148.
Programmierung des ARM7-LPC2148 für die Servomotorsteuerung
Um ARM7-LPC2148 zu programmieren, benötigen wir das keil uVision & Flash Magic Tool. Wir verwenden ein USB-Kabel, um den ARM7 Stick über einen Micro-USB-Anschluss zu programmieren. Wir schreiben Code mit Keil und erstellen eine Hex-Datei. Anschließend wird die HEX-Datei mit Flash Magic auf den ARM7-Stick geflasht. Um mehr über die Installation von keil uVision und Flash Magic und deren Verwendung zu erfahren, folgen Sie dem Link Erste Schritte mit dem ARM7 LPC2148-Mikrocontroller und programmieren Sie ihn mit Keil uVision.
Schritte zur Konfiguration von LPC2148 für PWM und ADC zur Steuerung des Servomotors
Schritt 1: - Fügen Sie die erforderlichen Header-Dateien für die Codierung von LPC2148 hinzu
#einschließen
Schritt 2: - Als Nächstes konfigurieren Sie die PLL für die Taktgenerierung, indem sie den Systemtakt und den Peripherietakt des LPC2148 gemäß den Anforderungen der Programmierer einstellt. Die maximale Taktfrequenz für LPC2148 beträgt 60 MHz. Die folgenden Zeilen werden zum Konfigurieren der PLL-Taktgenerierung verwendet.
void initilizePLL (void) // Funktion zur Verwendung von PLL zur Taktgenerierung { PLL0CON = 0x01; PLL0CFG = 0x24; PLL0FEED = 0xAA; PLL0FEED = 0x55; while (! (PLL0STAT & 0x00000400)); PLL0CON = 0x03; PLL0FEED = 0xAA; PLL0FEED = 0x55; VPBDIV = 0x01; }}
Schritt 3: - Als nächstes müssen Sie die PWM-Pins und die PWM-Funktion des LPC2148 mithilfe des PINSEL-Registers auswählen. Wir verwenden PINSEL0, da wir P0.1 für die PWM-Ausgabe von LPC2148 verwenden.
PINSEL0 - = 0x00000008; // Pin P0.1 von LPC2148 als PWM3 setzen
Schritt 4: - Als nächstes müssen wir die Timer mit PWMTCR (Timer Control Register) zurücksetzen.
PWMTCR = 0x02; // Zähler für PWM zurücksetzen und deaktivieren
Und dann als nächstes den Prescale-Wert einstellen, der über die Auflösung von PWM entscheidet.
PWMPR = 0x1D; // Prescale Registerwert
Schritt 5: - Stellen Sie als Nächstes das PWMMCR (PWM Match Control Register) ein, während es den Vorgang wie Zurücksetzen und Interrupts für PWMMR0 und PWMMR3 einstellt.
PWMMCR = 0x00000203; // Zurücksetzen und bei MR0-Übereinstimmung unterbrechen, bei MR3-Übereinstimmung unterbrechen
Schritt 6: - Die maximale Periode des PWM-Kanals wird mit PWMMR0 eingestellt und die Tonne des PWM-Arbeitszyklus wird anfänglich auf 0,65 ms eingestellt
PWMMR0 = 20000; // Zeitraum der PWM-Welle, 20 ms PWMMR3 = 650; // Tonne PWM-Welle 0,65 ms
Schritt 7: - Als nächstes müssen wir die Latch-Aktivierung mit PWMLER auf die entsprechenden Übereinstimmungsregister setzen
PWMLER = 0x09; // Latch-Freigabe für PWM3 und PWM0
(Wir verwenden PWMMR0 & PWMMR3) Aktivieren Sie also das entsprechende Bit, indem Sie 1 in PWMLER setzen
Schritt 8: - Um den PWM-Ausgang an den Pin zu aktivieren, müssen Sie den PWMTCR verwenden, um die PWM-Timer-Zähler und PWM-Modi zu aktivieren.
PWMPCR = 0x0800; // PWM3 und PWM 0 aktivieren, einkantengesteuertes PWM PWMTCR = 0x09; // PWM und Zähler aktivieren
Schritt 9: - Jetzt müssen wir die Potentiometerwerte zum Einstellen des Arbeitszyklus der PWM vom ADC-Pin P0.28 abrufen. Daher verwenden wir das ADC-Modul in LPC2148, um den Analogeingang des Potentiometers (0 bis 3,3 V) in die ADC-Werte (0 bis 1023) umzuwandeln.
Schritt 10: - Zur Auswahl des ADC-Pins P0.28 in LPC2148 verwenden wir
PINSEL1 = 0x01000000; // P0.28 als ADC INPUT einstellen AD0CR = (((14) << 8) - (1 << 21)); // Einstellen von Uhr und PDN für die A / D-Wandlung
Die folgenden Zeilen erfassen den Analogeingang (0 bis 3,3 V) und wandeln ihn in einen digitalen Wert (0 bis 1023) um. Und dann werden diese digitalen Werte durch 4 geteilt, um sie in (0 bis 255) umzuwandeln, und schließlich als PWM-Ausgang in P0.1-Pin von LPC2148 eingespeist. Hier konvertieren wir die Werte von 0-1023 nach 0-255, indem wir sie durch 4 teilen, da die PWM von LPC2148 eine 8-Bit-Auflösung hat (28).
AD0CR - = (1 << 1); // AD0.1-Kanal in ADC-Registerverzögerungszeit auswählen (10); AD0CR - = (1 << 24); // Starten Sie die A / D-Wandlung, während ((AD0DR1 & (1 << 31)) == 0); // Überprüfen Sie das DONE-Bit im ADC-Datenregister adcvalue = (AD0DR1 >> 6) & 0x3ff; // Erhalte das ERGEBNIS aus dem ADC-Datenregister Dutycycle = adcvalue / 4; // Formel zum Abrufen von Dutycycle-Werten von (0 bis 255) PWMMR1 = Dutycycle; // Tastverhältniswert auf PWM-Übereinstimmungsregister setzen PWMLER - = (1 << 1); // PWM-Ausgabe mit Tastverhältniswert aktivieren
Schritt 11: - Als nächstes zeigen wir diese Werte im LCD-Anzeigemodul (16X2) an. Daher fügen wir die folgenden Zeilen hinzu, um das LCD-Anzeigemodul zu initialisieren
Void LCD_INITILIZE (void) // Funktion zum Vorbereiten des LCD { IO0DIR = 0x0000FFF0; // Setzt Pin P0.12, P0.13, P0.14, P0.15, P0.4, P0.6 als OUTPUT- Verzögerungszeit (20); LCD_SEND (0x02); // lcd im 4-Bit-Betriebsmodus initialisieren LCD_SEND (0x28); // 2 Zeilen (16X2) LCD_SEND (0x0C); // Anzeige am Cursor aus LCD_SEND (0x06); // Auto-Inkrement-Cursor LCD_SEND (0x01); // Anzeige löschen LCD_SEND (0x80); // Erste Zeile erste Position }
Da wir LCD im 4-Bit-Modus mit LPC2148 verbunden haben, müssen wir Werte senden, die als Nibble by Nibble angezeigt werden (Upper Nibble & Lower Nibble). Daher werden die folgenden Zeilen verwendet.
void LCD_DISPLAY (char * msg) // Funktion zum Drucken der nacheinander gesendeten Zeichen { uint8_t i = 0; while (msg! = 0) { IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0xF0) << 8)); // Sendet Upper Nibble IO0SET = 0x00000050; // RS HIGH & ENABLE HIGH zum Drucken von Daten IO0CLR = 0x00000020; // RW LOW Schreibmodus-Verzögerungszeit (2); IO0CLR = 0x00000040; // EN = 0, RS und RW unverändert (dh RS = 1, RW = 0) Verzögerungszeit (5); IO0PIN = ((IO0PIN & 0xFFFF00FF) - ((msg & 0x0F) << 12)); // Sendet Lower Nibble IO0SET = 0x00000050; // RS & EN HIGH IO0CLR = 0x00000020; Verzögerungszeit (2); IO0CLR = 0x00000040; Verzögerungszeit (5); i ++; } }
Um diese ADC- und PWM-Werte anzuzeigen, verwenden wir die folgenden Zeilen in der Funktion int main () .
LCD_SEND (0x80); sprintf (displayadc, "adcvalue =% f", Dutycycle); LCD_DISPLAY (displayadc); // ADC-Wert anzeigen (0 bis 1023) angle = (adcvalue / 5.7); // Formel zum Konvertieren des ADC-Werts in einen Winkel (o bis 180 Grad) LCD_SEND (0xC0); Sprintf (Winkelwert, "ANGLE =%. 2f Grad", Winkel); LCD_DISPLAY (Winkelwert);
Der vollständige Code und die Videobeschreibung des Tutorials sind unten angegeben