Übernehmen Sie die Kontrolle über die Lego-Power-Funktionen

Über dieses Projekt

Hast du eines dieser tollen Lego Power Functions Modelle mit Elektromotoren und Servomotoren? In diesem Tutorial zeige ich Ihnen, wie Sie Ihr Lego-Modell mit Ihrem Arduino und einem Minimum an elektronischen Komponenten steuern können. Ich werde die Schaltungen und die Programmierung detailliert erklären, um dieses Tutorial für Anfänger leicht verständlich zu machen. Das Lego-Modell musst du selbst bauen (wenn du keinen Sohn hast), dabei helfe ich dir nicht.

Wir werden auch lernen, wie man mit dem MIT-App-Erfinder unsere eigene Android-Fernbedienungs-App programmiert. Bald haben Sie Ihren eigenen Lego-Mars-Rover in Ihrem Garten!

Dies ist mein erstes Arduino-Projekt und mein Sohn hat ein wunderschönes Lego Technic Automodell (9398 4X4 Crawler) mit Lego Power Functions:ein Lego Servo Motor zum Lenken und zwei Lego L-Motoren zum Fahren. Er erlaubte mir, das Auto für dieses Projekt zu verwenden (solange ich keine Motorkabel zerschnitten habe). Hier testen wir den fertigen Prototyp:

Die Verkabelung der Power Functions verstehen

Kaufen Sie zunächst einige Lego Power Functions Verlängerungskabel (Artikel 8886 im Lego Webshop). Als nächstes schneiden Sie sie (ernsthaft) auf. Wir werden einige "Break-out"-Kabel herstellen, die an einem Ende Legosteine ​​​​und am anderen Ende Stifte haben. Löten Sie die Pins auf oder ähnliches. Hier ist die Verkabelung erklärt:

GND steht für Ground, das ist der Minuspol (-) des Akkupacks (Anode). C1 und C2 können die Polarität umschalten, damit die Motoren und Servos die Richtung wechseln. TechnicRobot hat ein schönes Video gemacht, das alles im Detail erklärt. (WARNUNG:Sie tun dies auf eigene Verantwortung. Ich übernehme keine Verantwortung, wenn Sie etwas ruinieren!) Für den Lego-Servostecker müssen Sie alle vier Kabel mit Pins anlöten. Sie können den hellgrauen Stecker verwenden. Für das Stromkabel, das die Batteriebox mit dem Steckbrett verbindet, benötigen wir nur +9 Volt und GND, aber Sie müssen den dunkelgrauen Stecker verwenden (da Sie einen Stecker benötigen):

Für das Motorkabel müssen wir nur C1 und C2 verbinden und Sie können einen hellgrauen Stecker verwenden. (Lesen Sie die Schaltpläne für Details).

Steuerung eines Lego-Motors mit dem L293D-Chip

Wir wollen eine variable Geschwindigkeitssteuerung für unsere Gleichstrommotoren und eine Positionssteuerung für unser Lego-Servo. Dies wird durch Pulsweitenmodulation (PWM) erreicht. Die Programmiersprache des Arduino macht PWM einfach zu bedienen; Rufen Sie einfach analogWrite (pin, dutyCycle) auf, wobei dutyCycle ein Wert von 0 bis 255 ist. Die PWM-Pins sind auf Ihrem Arduino mit ~ gekennzeichnet.

Die Arduino-Ausgangspins sind 5 Volt und max. 30 mA, während die Lego-Motoren 9 Volt benötigen und jeweils mehr als 100 mA ziehen. Wir brauchen eine Art "Schaltgerät" dazwischen. Außerdem wollen wir die Gleichstrommotoren in beide Richtungen betreiben können. Diese Funktionen werden durch eine sogenannte H-Brücke gelöst. Wir verwenden den L293D, der zwei H-Brücken auf einem integrierten Chip enthält, dh wir können die Lego-Motoren (M) parallel an einer Seite und das Lego-Servo (S) an der anderen Seite des Chips anschließen. (Wenn Sie die beiden Motoren unabhängig voneinander steuern möchten, benötigen Sie einen zweiten L293D). Das Lego-Servo muss auch an GND und Lego +9 Volt angeschlossen werden.

Der Chip hält Lego +9 Volt und Arduino +5 Volt komplett getrennt. Verbinden Sie sie niemals miteinander, sonst beschädigen Sie etwas! Sie müssen jedoch alle Masseleitungen miteinander und mit den L293D-Massestiften verbinden.

Von unserem Arduino aus verwenden wir Pin 9, um die Motordrehzahl zu steuern, und Pins 2 und 5, um die Drehrichtung zu steuern. Das Lego-Servo wird wie ein Motor gesteuert:Wir verbinden Pin 3 für Position und Pin 6 und 8 für Richtung (links oder rechts).

Am Anfang unseres Programms definieren wir die verwendeten Arduino-Pins als Konstanten. Außerdem definieren wir einige Variablen, die wir verwenden werden, um die Motoren zu steuern:

// Digitale Ausgangspins der Motorsteuerung definiert als globale Konstantenconst int controlPin1A =2; const int controlPin2A =5; const int ENablePin =9; // Digitale Ausgangspins der Servosteuerung, die als globale Konstanten definiert sind const int controlPin3A =6; const int controlPin4A =8; const int servoENablePin =3; // Globale Variablen der Motorsteuerung:int motorSpeed ​​=0; // Motordrehzahl 0..255int motorDirection =1; // Vorwärts (1) oder Rückwärts (0) // Globale Variablen der Servosteuerung:int Steering =0; // Servoposition 0..255int SteeringDirection =0; // Links (0) und Rechts (1) 

Im Setup definieren wir diese Pins mit dem Befehl pinmode() als Ausgänge und setzen sie dann mit digitalWrite() auf 0 Volt.

void setup () { // Sonstiges .... // Digitale Ausgangspins deklarieren:pinMode (controlPin1A, OUTPUT); // 1A PinMode (controlPin2A, OUTPUT); // 2A PinMode (ENablePin, OUTPUT); // EN1,2 PinMode (controlPin3A, OUTPUT); // 3A PinMode (controlPin4A, OUTPUT); // 4A PinMode (servoENablePin, OUTPUT); // EN3,4 digitalWrite (ENablePin, LOW); // Motor aus DigitalWrite (servoENablePin, LOW); // Lenkung zentriert} 

Jetzt müssen wir verstehen, wie der L293D-Chip die Drehrichtung der Motoren steuert. Wir müssen folgende Signale liefern (High ==5 Volt; Low ==0 Volt):

• EN1,2     1A       2A

• Hoch       Hoch   Niedrig     Motor dreht nach links (Vorwärts; motorDirection ==1)

• Hoch       Niedrig    Hoch    Motor dreht nach rechts (Reverse; motorDirection ==0)

• EN3,4     3A     4A

• High       High   Low     Servo dreht nach links (steeringDirection ==0)

• High       Low    High    Servo dreht nach rechts (steeringDirection ==1)

In Ordnung. Wir sind bereit, ein Unterprogramm zu schreiben, das die globalen Variablen für Richtung und Geschwindigkeit/Position liest und die Motoren und Servos steuert:

void SetMotorControl () { if (motorDirection ==1) // Vorwärts { digitalWrite (controlPin1A, HIGH); digitalWrite (controlPin2A, LOW); aufrechtzuerhalten. Sonst // Reverse { DigitalWrite (controlPin1A, LOW); digitalWrite (controlPin2A, HIGH); } analogWrite (ENablePin, motorSpeed); // Geschwindigkeit wenn (steeringDirection ==0) // Links { DigitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, LOW); aufrechtzuerhalten. Sonst // Rechts { DigitalWrite (controlPin3A, LOW); digitalWrite (controlPin4A, HIGH); } analogWrite (servoENablePin, Lenkung); //Servoposition} 

Einfache RC-Android-App mit Joystick

Als Nächstes erstellen wir eine einfache Android-App zur Steuerung des Modells. (Wenn du die fertige App zuerst testen möchtest:Ich habe sie im Google Play Store für dich bereitgestellt. Hier der Link:Arduino RC Car Bluetooth).

Wir verwenden den MIT App Inventor 2. MIT App Inventor ist eine innovative Einführung in die Programmierung und App-Erstellung für Anfänger. Mark Friedman von Google und MIT-Professor Hal Abelson leiteten gemeinsam die Entwicklung von App Inventor. Es läuft als Webservice, der von Mitarbeitern des MIT Center for Mobile Learning verwaltet wird.

Rufen Sie auf Ihrem Android-Telefon Google Play auf und installieren Sie die MIT AI2 Companion-App. Öffnen Sie auf Ihrem Computer den Link zu meiner RC-App im Firefox- oder Chrome-Browser (Internet Explorer wird nicht unterstützt). Sie müssen sich mit Ihrer Gmail-Adresse einloggen und ein Konto erstellen, um den Quellcode zu sehen. Wenn Sie die Begleit-App auf Ihrem Telefon öffnen, können Sie den Quellcode im Browser einsehen, Änderungen daran vornehmen und sofort auf Ihrem Telefon testen.

Im Browser sehen Sie nun die Designer-Ansicht der App:

Unten sehen wir das orangefarbene Pad mit dem blauen Joystickball darin. Wechseln Sie nun in die Blocks-Ansicht, um das Programm zu sehen. Das Herzstück des Programms ist ein Wenn-Block, der die Bewegungen Ihres Fingers beim Berühren und Ziehen des blauen Joystickballs verfolgt:

Die Position Ihres Fingers wird in den beiden Variablen currentX erfasst und aktuellY und wird verwendet, um Werte für die beiden Variablen Lenkung zu berechnen und Geschwindigkeit (Bereich:-100..0..+100). Zuerst prüft das Programm, ob sich Ihr Finger außerhalb des Pads befindet und begrenzt die Werte auf +/- 100. Befindet sich der Finger innerhalb des Pads, berechnet das Programm Werte für die Lenkung und Geschwindigkeit . Als nächstes generiert das Programm eine Befehlszeichenfolge der Form:

Der Befehl beginnt mit "RC" für die Fernbedienung (die Idee ist, dass Sie in Zukunft möglicherweise mehr Befehle haben möchten), gefolgt von einem Komma. Dann senden wir die Werte für die Steuerung und Geschwindigkeit . Das Newline-Zeichen ('\n') am Ende des Befehls signalisiert dem Arduino, dass der Befehl abgeschlossen ist. Diese Befehlszeichenfolge wird über Bluetooth an das Arduino gesendet. Zu Ihrer Information wird die Zeichenfolge auch auf dem Bildschirm angezeigt.

Einlesen von Bluetooth-Befehlen in den Arduino

Um die Bluetooth-Befehlszeichenfolgen zu lesen, müssen wir ein HC-05 Bluetooth-Modul anschließen. Schauen Sie sich Ihr Modul an:

Meiner hat 6 Pins. Wir brauchen nur vier Pins. VCC ist die (positive) Versorgungsspannung und GND ist Masse. Das Modul toleriert 6 Volt Versorgungsspannung, was bedeutet, dass wir es an den Arduino 5 Volt Power Pin anschließen können. TXD und RXD sind die seriellen Signale. Wir müssen die Linien überqueren und TXD mit Arduino RXD (Pin 0) verbinden und umgekehrt. Vorsicht: Es gibt LEVEL:3.3V an, was bedeutet, dass der RXD nicht kann direkt an das 5V arduino TXD (Pin 1) angeschlossen werden. Wir müssen einen Spannungsteiler mit drei 1-kOhm-Widerständen konstruieren, um eine Ausgangsspannung von 2/3 von 5V zu erzeugen (siehe Schaltpläne). Andererseits kann das TXD-Signal von 3.3V direkt an Arduino RXD angeschlossen werden. Der Arduino erkennt 3,3 Volt als HIGH.

Da Pin 0 und 1 mit dem USB-Port Ihres Arduino geteilt werden, müssen Sie die RXD- und TXD-Signale von Pin 0 und 1 trennen, während Sie das Programm über USB auf das Board hochladen. Der Upload funktioniert nicht, wenn Sie die Kabel nicht trennen.

Als nächstes müssen Sie das HC-05-Modul mit Ihrem Android-Gerät koppeln. Bluetooth einschalten; Starten Sie die App; drücken Sie "Bluetooth-Verbindung"; Machen Sie Ihr Telefon sichtbar und suchen Sie nach einem Gerät namens HC-05 oder ähnlich. Wählen Sie das Gerät aus. Sie werden nach einem Code gefragt. Drücken Sie "1234". Wenn Sie zum Joystick-Bildschirm zurückkehren, sollte grün "verbunden" angezeigt werden.

Schauen wir uns nun den Code an:

// Serielle Puffergröße:Berechne basierend auf der maximalen Eingabegröße, die für einen Befehl erwartet wird#define INPUT_SIZE 30 void loop() {// Hole den nächsten Befehl von seriellem Bluetooth (füge 1 Byte für abschließende 0) hinzu char input[ INPUT_SIZE + 1]; // Array vom Typ char (C-String) // Seriell lesen bis neue Zeile oder Puffer voll oder Zeitüberschreitung Bytegröße =Serial.readBytesUntil('\n', input, INPUT_SIZE); // Fügen Sie die letzte 0 hinzu, um den C-String zu beenden input[size] =0; // String aufteilen, der die Form hat:"RC,steering,speed,\n\0" char* command =strtok(input, ","); // Befehl (RC) // RCsteering im Bereich:-100 (links).. 0 .. 100 (rechts) char* RCsteering =strtok(NULL, ","); // RCspeed im Bereich:-100 (volle Geschwindigkeit rückwärts).. 0 .. 100 (volle Geschwindigkeit vorwärts) char* RCspeed =strtok(NULL, ","); int iRCsteering =atoi (RCsteering); // String in Integer umwandeln int iRCspeed =atoi (RCspeed); // String in Integer umwandeln // Rest des Programms}  

Der von der Android-App gesendete String wird in ein spezielles String-Konstrukt eingelesen:einen C-String mit Nullterminierung. (Das 0-Zeichen sagt dem Programm, dass es am Ende des Strings angekommen ist). Dies geschieht mit der Funktion Serial.readBytesUntil('\n', input, ...), die von der seriellen Schnittstelle (Bluetooth) liest, bis sie ein Newline-Zeichen ('\n') erhält. Auf diese Weise lesen wir weiter Bytes, bis wir einen vollständigen Befehl in Eingabe haben :

Eine sehr effiziente Methode zur Verarbeitung von Eingaben ist die Zeichenfolgen-Token-Funktion, die die Zeichenfolge mit einem Komma als Trennzeichen in Teile schneidet. Der erste Aufruf von strtok() gibt "RC" zurück. Die nachfolgenden Teile des Befehls werden dann gelesen, indem NULL an strtok() übergeben wird. Die Rückgabewerte werden in RCsteering stored gespeichert und RCspeed . Diese Variablen sind eigentlich Zeiger auf Positionen in Eingabe . Die Funktion atoi() wandelt sie schließlich in ganze Zahlen um. Jetzt haben wir:

Wir sind jetzt fast fertig. Wir müssen diese Werte mit 2,55 multiplizieren, bevor wir sie an unsere Routine SetMotorControl() weitergeben (denken Sie daran, dass die Motordrehzahl im Bereich 0..255 lag). Studieren Sie den Rest des Programms im Abschnitt CODE, bauen Sie die Schaltung und testen Sie Ihr ferngesteuertes Lego-Modell!

Was kommt als nächstes?

Jetzt, da Sie ein Arduino haben, das Ihr Lego-Modell steuert, möchten Sie dieses Modell vielleicht als Roboterplattform verwenden:Fügen Sie einige Ultraschall-Ping-Sensoren hinzu, programmieren Sie Ihre eigene Hindernisvermeidungslogik und bauen Sie Ihren eigenen selbstfahrenden Mars-Rover. Oder fügen Sie der Fernbedienung weitere Befehle und dem Modell weitere Funktionen hinzu. Aber zuerst finden Sie eine Methode für den Arduino, um herauszufinden, dass das Modell außerhalb der Reichweite der Bluetooth-Verbindung gereist ist, und stoppen Sie das Modell. Erzähl mir von deiner Lösung.

Schon bald werden Sie feststellen, dass ein Prototyping-Steckbrett und lose Kabel für ein sich bewegendes Modell keine gute Idee sind. Holen Sie sich einen Adafruit-Motorschutz mit großen Klemmenleistenanschlüssen und verdrahten und programmieren Sie ihn neu. Dadurch werden auch digitale Signale frei, die Sie stattdessen für Eingänge verwenden können. Sie können auch eine Sensorabschirmung für eine bessere Verbindung Ihrer Sensoren in Betracht ziehen.

Erzählen Sie mir von Ihren spannenden Projekten!

Code

• Legocar_v3_bluetooth

Legocar_v3_bluetoothArduino

/* Lego Powerfunctions Automodell über Bluetooth gesteuert Arduino Uno steuert Motoren und Servo Ferngesteuert mit Android App entwickelt mit MIT App Inventor 2 Schaltung:* Serielle Kommunikation (verwendet Uno Pin 0,1) Bluetooth-Modul ist angeschlossen (muss an muss beim Laden des Programms über USB abgenommen werden) * L293D mit Motor (verwendet Uno-Digitalpins 2,5,9) * L293D mit Servo (verwendet Uno-Digitalpins 6,8,3) */// Verwendete Bibliotheken:#include  // Serial Peripheral Interface Library#include  // enthält Funktion strtok:String in Token aufteilen // Serielle Puffergröße:Berechnung basierend auf der maximalen Eingabegröße, die für einen Befehl über die serielle Bluetooth-Schnittstelle erwartet wird#define INPUT_SIZE 30/ / Digitale Ausgangspins der Motorsteuerung, definiert als globale Konstanten (4-Rad-Antrieb mit 2 Lego-Motoren):const int controlPin1A =2; // L293D-Treibereingang 1A an Pin Nr. 2 http://www.ti.com/lit/ds/symlink/l293.pdf verbunden mit Arduino Digitalausgang Pin 2const int controlPin2A =5; // L293D-Treibereingang 2A an Pin Nr. 7 verbunden mit Arduino-Digitalausgang Pin 5const int ENablePin =9; // L293D ENable (1,2) Eingang an Pin Nr. 1 verbunden mit Arduino Digitalausgang Pin 9 // Servosteuerung Digitalausgangspins definiert als globale Konstanten (Servolenkung mit 1 Lego Servo):const int controlPin3A =6; // L293D-Treibereingang 3A an Pin Nr. 10, verbunden mit Arduino-Digitalausgang Pin 6const int controlPin4A =8; // L293D-Treibereingang 4A an Pin Nr. 15 verbunden mit Arduino-Digitalausgang Pin 8 const int servoENablePin =3; // L293D ENable (3,4) Eingang an Pin Nr. 9, verbunden mit Arduino Digitalausgang Pin 3 // Globale Variablen der Motorsteuerung:int motorSpeed ​​=0; // Motordrehzahl 0..255int motorDirection =1; // Vorwärts (1) oder Rückwärts (0) // Globale Variablen der Servosteuerung:int Steering =0; // Servoposition 0..255int SteeringDirection =0; // Links (0) und rechts (1)void setup () { Serial.begin (9600); // serielle Kommunikation initialisieren Serial.setTimeout (1000); // 1000 ms Timeout // Digitale Ausgangspins deklarieren:pinMode (controlPin1A, OUTPUT); // 1A PinMode (controlPin2A, OUTPUT); // 2A PinMode (ENablePin, OUTPUT); // EN1,2 PinMode (controlPin3A, OUTPUT); // 3A PinMode (controlPin4A, OUTPUT); // 4A PinMode (servoENablePin, OUTPUT); // EN3,4 digitalWrite (ENablePin, LOW); // Motor aus DigitalWrite (servoENablePin, LOW); // Lenkung zentriert}void loop () {// Hole den nächsten Befehl von seriellem Bluetooth (füge 1 Byte für letzte 0) hinzu char input[INPUT_SIZE + 1]; // Array vom Typ char (C-String) mit Null-Terminierung (https://www.arduino.cc/en/Reference/String) Bytegröße =Serial.readBytesUntil('\n', input, INPUT_SIZE); // Seriell lesen, bis neue Zeile oder Puffer voll oder Zeitüberschreitung // Fügen Sie die letzte 0 hinzu, um die C-Zeichenfolge zu beenden input[size] =0; // Befehl lesen, der ein C-String der Form ist:"RC,RCsteering,RCspeed,\n\0" (endet mit einem Zeilenumbruch und einer Null) char* command =strtok(input, ","); // Befehl vorerst ignorieren (RC for Remote Control ist der einzige Befehl, der vorerst von der App gesendet wird) char* RCsteering =strtok(NULL, ","); // als nächstes kommt RCsteering im Bereich:-100 (links).. 0 .. 100 (rechts) char* RCspeed =strtok(NULL, ","); // als nächstes kommt RCspeed, das im Bereich liegt:-100 (volle Geschwindigkeit rückwärts).. 0 .. 100 (volle Geschwindigkeit vorwärts) int iRCsteering =atoi (RCsteering); // String RCsteering in Integer umwandeln iRCsteering int iRCspeed =atoi (RCspeed); // String RCspeed in Integer umwandeln iRCspeed // Motor- und Servosteuerungsvariablen setzen if (iRCsteering> 0) SteeringDirection =1; // rechts abbiegen, wenn iRCsteering =1..100 sonst SteeringDirection =0; // links abbiegen, wenn iRCsteering =-100..0 Lenkung =int(2.55*abs(iRCsteering)); // Servoposition 0..255 basierend auf Befehl 0..100 if (iRCspeed> 0) motorDirection =1; // Auto vorwärts setzen, wenn iRCspeed =1..100 else motorDirection =0; // Auto rückwärts setzen, wenn iRCspeed =-100..0 motorSpeed ​​=int(2.55*abs(iRCspeed)); // Setze Geschwindigkeit 0..255 basierend auf Befehl 0..100 SetMotorControl(); // Motorrichtung und Geschwindigkeit einstellen}void SetMotorControl()/*L293 Logik:EN1,2 1A 2A HHL Motor dreht nach links (Vorwärts; motorDirection ==1) HLH Motor dreht nach rechts (Reverse; motorDirection ==0) EN3,4 3A 4A HHL Servo dreht links (steeringDirection ==0) HLH Servo dreht rechts (steeringDirection ==1)Motordrehzahl:PWM-Signal an EN1,2 (490 Hz; digitaler Ausgangswert 0..255 für motorSpeed)Servoposition:PWM-Signal an EN3,4 (490 Hz; digitaler Ausgangswert 0..255 für Position; 0 ist geradeaus)*/{ if (motorDirection ==1) //Forward { digitalWrite(controlPin1A, HIGH); digitalWrite (controlPin2A, LOW); aufrechtzuerhalten. Sonst // Reverse { DigitalWrite (controlPin1A, LOW); digitalWrite (controlPin2A, HIGH); } analogWrite (ENablePin, motorSpeed); // Geschwindigkeit wenn (steeringDirection ==0) // Links { DigitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, LOW); aufrechtzuerhalten. Sonst // Rechts { DigitalWrite (controlPin3A, LOW); digitalWrite (controlPin4A, HIGH); } analogWrite (servoENablePin, Lenkung); //Servoposition}

Github Lego-Auto-Arduino

Schaltpläne

Github Lego-Auto-Arduino