Neem de controle over Lego Power-functies

Over dit project

Heb jij zo'n geweldige Lego Power Functions-modellen met elektromotoren en servomotoren? In deze tutorial laat ik je zien hoe je je Lego-model kunt besturen met je Arduino en een minimum aan elektronische componenten. Ik zal de circuits en programmering in detail uitleggen om deze tutorial gemakkelijk begrijpelijk te maken voor beginners. Het Lego-model dat je zelf moet bouwen (als je geen zoon hebt), daar ga ik je niet mee helpen.

We zullen ook leren hoe we de uitvinder van de MIT-app kunnen gebruiken om onze eigen Android-app op afstand te programmeren. Binnenkort heb je je eigen Lego Mars-rover in je achtertuin!

Dit is mijn eerste Arduino-project en mijn zoon heeft een prachtig Lego Technic automodel (9398 4X4 Crawler) met Lego Power Functions:een Lego Servo Motor om te sturen en twee Lego L-motoren om te rijden. Hij stond me toe de auto voor dit project te gebruiken (zolang ik geen motorkabels doorsneed). Hier testen we het voltooide prototype:

De bedrading van de Power Functions begrijpen

Koop eerst wat Lego Power Functions Verlengkabels (item 8886 in de Lego webshop). Snijd ze vervolgens in stukken (serieus). We zullen een aantal "break-out"-kabels maken met aan het ene uiteinde Legoblokjes en aan het andere uiteinde pinnen. Soldeer de pinnen op of iets dergelijks. Hier is de bedrading uitgelegd:

GND staat voor Ground, de negatieve pool (-) van het batterijpakket (anode). C1 en C2 kunnen van polariteit wisselen om de motoren en servo's van richting te laten veranderen. TechnicRobot heeft een mooie video gemaakt waarin alles tot in detail wordt uitgelegd. (WAARSCHUWING:je doet dit op eigen verantwoordelijkheid. Ik ben niet verantwoordelijk als je iets verpest!) Voor de Lego-servoconnector moet je op alle vier de kabels pinnen solderen. Je kunt de lichtgrijze stekker gebruiken. Voor de stroomkabel die de accubak met het breadboard verbindt, hebben we alleen +9 Volt en GND nodig, maar je moet de donkergrijze stekker gebruiken (omdat je een mannelijke connector nodig hebt):

Voor de motorkabel hoeven we alleen C1 en C2 aan te sluiten en kunt u een lichtgrijze stekker gebruiken. (Bestudeer de schema's voor details).

Een Lego-motor besturen met de L293D-chip

We willen variabele snelheidsregeling voor onze DC-motoren en positieregeling voor onze Lego-servo. Dit wordt bereikt door Pulse Width Modulation (PWM). De programmeertaal van de Arduino maakt PWM gemakkelijk te gebruiken; bel gewoon analogWrite(pin, dutyCycle), waarbij dutyCycle een waarde is van 0 tot 255. De PWM-pinnen zijn gemarkeerd met ~ op je arduino.

De Arduino-uitgangspinnen zijn 5 Volt en max. 30 mA terwijl de Lego-motoren 9 Volt nodig hebben en elk meer dan 100 mA trekken. We hebben daartussen een soort "schakelapparaat" nodig. Ook willen we de gelijkstroommotoren in beide richtingen kunnen laten draaien. Deze functies worden opgelost door een zogenaamde H-brug. We zullen de L293D gebruiken, die twee H-bruggen op één geïntegreerde chip bevat, wat betekent dat we de Lego-motoren (M) parallel aan de ene kant en de Lego-servo (S) aan de andere kant van de chip kunnen aansluiten. (Als u de twee motoren onafhankelijk van elkaar wilt bedienen, heeft u een tweede L293D nodig). De Lego-servo moet ook worden aangesloten op GND en Lego +9 Volt.

De chip houdt Lego +9 Volt en Arduino +5 Volt volledig gescheiden. Verbind ze nooit met elkaar, anders beschadig je iets! Maar je moet alle aardingslijnen met elkaar verbinden en met de L293D-aardingspinnen.

Vanuit onze Arduino zullen we pin 9 gebruiken om de motorsnelheid te regelen en pinnen 2 en 5 om de draairichting te regelen. De Lego-servo wordt aangestuurd als een motor:we verbinden pin 3 voor positie en pins 6 en 8 voor richting (links of rechts).

Bovenaan ons programma definiëren we de gebruikte Arduino-pinnen als constanten. Verder definiëren we enkele variabelen die we zullen gebruiken om de motoren te besturen:

// Motorbesturing digitale uitgangspinnen gedefinieerd als globale constantenconst int controlPin1A =2; const int controlPin2A =5; const int ENablePin =9; // Servobesturing digitale uitgangspinnen gedefinieerd als globale constanten const int controlPin3A =6; const int controlPin4A =8; const int servoENablePin =3; // Algemene variabelen motorbesturing:int motorSpeed ​​=0; // Motorsnelheid 0..255int motorDirection =1; // Vooruit (1) of achteruit (0)// Servobesturing globale variabelen:int steering =0; // Servopositie 0..255int stuurrichting =0; // Links (0) en Rechts (1) 

In de setup definiëren we deze pinnen als uitgangen met de opdracht pinmode() en stellen ze vervolgens in op 0 Volt met digitalWrite().

void setup() {//other stuff.... // Declareer digitale output pinnen: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, LAAG); // motor uit digitalWrite (servoENablePin, LOW); // besturing gecentreerd} 

Nu moeten we begrijpen hoe de L293D-chip de draairichting van de motoren regelt. We moeten de volgende signalen leveren (Hoog ==5 Volt; Laag ==0 Volt):

• EN1,2     1A       2A

• Hoog       Hoog   Laag     Motor draait naar links (Forward; motorDirection ==1)

• Hoog       Laag    Hoog    Motor draait naar rechts (Reverse; motorDirection ==0)

• EN3,4     3A     4A

• Hoog       Hoog   Laag     Servo draait naar links (steeringDirection ==0)

• Hoog       Laag    Hoog    Servo draait naar rechts (steeringDirection ==1)

OK. We zijn klaar om een ​​subroutine te schrijven die de globale variabelen voor richting en snelheid/positie leest en de motoren en servo bestuurt:

void SetMotorControl(){ if (motorDirection ==1) //Forward {digitalWrite(controlPin1A, HIGH); digitalWrite (controlPin2A, LAAG); } else //Reverse {digitalWrite(controlPin1A, LOW); digitalWrite(controlPin2A, HOOG); } analogWrite (ENablePin, motorSpeed); // Snelheid als (steeringDirection ==0) // Links {digitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, LAAG); } else //Right {digitalWrite(controlPin3A, LOW); digitalWrite(controlPin4A, HOOG); } analogWrite(servoENablePin, stuur); //Servopositie} 

Eenvoudige RC Android-app met joystick

Laten we vervolgens een eenvoudige Android-app bouwen om het model te besturen. (Als je de voltooide app eerst wilt testen:ik heb hem voor je beschikbaar gemaakt in de Google Play Store. Hier is de link:Arduino RC auto bluetooth).

We gebruiken de MIT-app-uitvinder 2. MIT App Inventor is een innovatieve introductie voor beginners tot programmeren en het maken van apps. Mark Friedman van Google en MIT-professor Hal Abelson leidden samen de ontwikkeling van App Inventor. Het draait als een webservice die wordt beheerd door medewerkers van MIT's Center for Mobile Learning.

Ga op je Android-telefoon naar Google Play en installeer de MIT AI2 Companion-app. Open op uw computer de link naar mijn RC-app in Firefox- of Chrome-browser (Internet Explorer niet ondersteund). Je moet inloggen met je gmail-adres en een account aanmaken om de broncode te zien. Als je de begeleidende app op je telefoon opent, kun je de broncode in de browser bekijken, deze wijzigen en direct op je telefoon testen.

In de browser ziet u nu de Designer-view van de app:

Onderaan zien we de oranje pad met de blauwe joystickball erin. Ga nu naar de Blocks-view om het programma te zien. Het hart van het programma is een wanneer-blok dat de bewegingen bijhoudt van uw vinger die de blauwe joystickbal aanraakt en sleept:

De positie van uw vinger wordt bijgehouden in de twee variabelen currentX en huidigeY en wordt gebruikt om waarden te berekenen voor de twee variabelen besturing en snelheid (bereik:-100..0..+100). Eerst controleert het programma of uw vinger zich buiten de pad bevindt en begrenst de waarden tot +/- 100. Als de vinger zich in de pad bevindt, berekent het programma waarden voor sturen en snelheid . Vervolgens genereert het programma een commandoreeks van de vorm:

Het commando begint met "RC" voor afstandsbediening (het idee is dat je in de toekomst misschien meer commando's wilt hebben) gevolgd door een komma. Dan sturen we de waarden voor besturing en snelheid . Het newline-teken ('\n') aan het einde van het commando is een signaal naar de Arduino dat het commando compleet is. Deze commandostring wordt via bluetooth naar de Arduino gestuurd. Ter referentie, de string wordt ook op het scherm weergegeven.

Bluetooth-commando's inlezen in de Arduino

Om de Bluetooth-opdrachtreeksen te kunnen lezen, moeten we een HC-05 Bluetooth-module aansluiten. Bekijk je module:

De mijne heeft 6 pinnen. We hebben maar vier pinnen nodig. VCC is (positieve) voedingsspanning en GND is aarde. De module tolereert 6 Volt voedingsspanning, wat betekent dat we hem kunnen aansluiten op de arduino 5 Volt power pin. TXD en RXD zijn de seriële signalen. We moeten de lijnen overschrijden en TXD verbinden met arduino RXD (pin 0) en vice versa. Wees voorzichtig: Er staat LEVEL:3.3V wat betekent dat de RXD niet direct worden aangesloten op de 5V arduino TXD (pin 1). We moeten een spanningsdeler bouwen met drie weerstanden van 1 kOhm om een ​​uitgangsspanning te produceren die 2/3 van 5V is (zie schema). Aan de andere kant kan het TXD-signaal van 3,3V direct worden aangesloten op Arduino RXD. De Arduino herkent 3,3 Volt als HOOG.

Omdat pin 0 en 1 worden gedeeld met de USB-poort van je Arduino, moet je de RXD- en TXD-signalen van pin 0 en 1 loskoppelen terwijl je het programma via USB naar het bord uploadt. Het uploaden werkt niet als je de kabels niet loskoppelt.

Vervolgens moet u de HC-05-module koppelen met uw Android-apparaat. Bluetooth inschakelen; start de app; druk op "Bluetooth verbinden"; maak je telefoon zichtbaar en zoek naar een apparaat met de naam HC-05 of iets dergelijks. Selecteer het apparaat. Er wordt om een ​​code gevraagd. Druk op "1234". Wanneer u terugkeert naar het joystick-scherm, zou het groen "verbonden" moeten zijn.

Laten we nu naar de code kijken:

// Seriële buffergrootte:bereken op basis van de maximale invoergrootte die wordt verwacht voor één opdracht#define INPUT_SIZE 30 void loop() {// Haal de volgende opdracht op van seriële bluetooth (voeg 1 byte toe voor de laatste 0) tekeninvoer [ INPUT_SIZE + 1]; // array van type char (C-string) // lees Serieel totdat nieuwe regel of buffer vol is of time-out bytegrootte =Serial.readBytesUntil('\n', input, INPUT_SIZE); // Voeg de laatste 0 toe om de C-string input [size] =0 te beëindigen; // Split string in de vorm:"RC,steering,speed,\n\0" char* command =strtok(input, ","); // commando (RC) // RCsteering in bereik:-100 (links).. 0 .. 100 (rechts) char* RCsteering =strtok(NULL, ","); // RCspeed in bereik:-100 (volledige snelheid achteruit).. 0 .. 100 (volledige snelheid vooruit) char* RCspeed =strtok(NULL, ","); int iRCsteering =atoi(RCsteering); // converteer string naar integer int iRCspeed =atoi(RCspeed); // convert string in integer //rest of program}  

De string die door de Android-app wordt verzonden, wordt ingelezen in een speciale string-constructie:een C-string met null-termination. (Het 0-teken vertelt het programma dat het aan het einde van de string is gekomen). Dit wordt gedaan door gebruik te maken van de functie Serial.readBytesUntil('\n', input, ...), die leest van de seriële interface (bluetooth) totdat het een newline-karakter ('\n') krijgt. Op die manier blijven we bytes lezen totdat we een compleet commando hebben in input :

Een zeer efficiënte manier om invoer te verwerken is de tekenreeksfunctie, die de tekenreeks in delen snijdt met een komma als scheidingsteken. De eerste aanroep van strtok() retourneert "RC". De volgende delen van de opdracht worden dan gelezen door NULL door te geven aan strtok(). De terugkerende waarden worden opgeslagen in RCsteering en RCspeed . Deze variabelen zijn eigenlijk verwijzingen naar posities in input . De functie atoi() zet ze uiteindelijk om in gehele getallen. Nu hebben we:

We zijn nu bijna klaar. We moeten deze waarden vermenigvuldigen met 2,55 voordat we ze doorgeven aan onze routine SetMotorControl() (Vergeet niet dat de motorsnelheid in het bereik van 0..255 lag). Bestudeer de rest van het programma in de CODE-sectie, bouw het circuit en test je op afstand bestuurbare Lego-model!

Wat nu?

Nu je een Arduino hebt die je Lego-model bestuurt, wil je dat model misschien als een robotica-platform gebruiken:voeg wat ultrasone ping-sensoren toe, programmeer je eigen obstakel-vermijdende logica en maak je eigen zelfrijdende robot Marsrover. Of voeg meer commando's toe aan de afstandsbediening en meer functies aan het model. Maar zoek eerst een methode voor de Arduino om erachter te komen dat het model buiten het bereik van de bluetooth-verbinding is gekomen en stop het model. Vertel me over je oplossing.

Al snel zul je ontdekken dat een prototype van een breadboard en losse kabels geen goed idee zijn voor een bewegend model. Koop een adafruit motorshield met grote aansluitblokconnectoren en bedraad en programmeer opnieuw. Dit maakt ook digitale signalen vrij die u in plaats daarvan voor ingangen kunt gebruiken. U kunt ook een sensorafscherming overwegen voor een betere aansluiting van uw sensoren.

Laat me weten wat je spannende projecten zijn!

/* Lego Powerfunctions automodel bestuurd via bluetooth Arduino Uno bestuurt motoren en servo Afstandsbediening met android app ontwikkeld met MIT App Inventor 2 Circuit:* Seriële communicatie (gebruikt Uno pin 0,1) Bluetooth-module is aangesloten (moet worden losgemaakt bij het laden van het programma via USB) * L293D met motor (gebruikt Uno digitale pinnen 2,5,9) * L293D met servo (gebruikt Uno digitale pinnen 6,8,3) */// Gebruikte bibliotheken:#include  // Serial Peripheral Interface Library#include  // bevat functie strtok:string splitsen in tokens// Seriële buffergrootte:berekenen op basis van maximale invoergrootte verwacht voor één opdracht via seriële Bluetooth-interface#define INPUT_SIZE 30/ / Motorbesturing digitale uitgangspinnen gedefinieerd als globale constanten (4 wielaandrijving met 2 Lego-motoren):const int controlPin1A =2; // L293D driver input 1A op pin nr 2 http://www.ti.com/lit/ds/symlink/l293.pdf aangesloten op Arduino digitale output pin 2const int controlPin2A =5; // L293D driver input 2A op pin nr 7 aangesloten op Arduino digitale output pin 5const int ENablePin =9; // L293D ENable (1,2) invoer op pin nr. 1 aangesloten op Arduino digitale uitvoerpin 9// Servobesturing digitale uitvoerpinnen gedefinieerd als globale constanten (Servobesturing met 1 Lego-servo):const int controlPin3A =6; // L293D driver input 3A op pin 10 aangesloten op Arduino digitale output pin 6const int controlPin4A =8; // L293D driver input 4A op pin 15 aangesloten op Arduino digitale output pin 8 const int servoENablePin =3; // L293D ENable(3,4) ingang op pin 9 aangesloten op Arduino digitale uitgang pin 3// Motorbesturing globale variabelen:int motorSpeed ​​=0; // Motorsnelheid 0..255int motorDirection =1; // Vooruit (1) of achteruit (0)// Servobesturing globale variabelen:int steering =0; // Servopositie 0..255int stuurrichting =0; // Links (0) en rechts (1) void setup () { Serial.begin (9600); // initialiseer seriële communicatie Serial.setTimeout (1000); // 1000 ms time-out // Declareer digitale uitgangspinnen: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, LAAG); // motor uit digitalWrite (servoENablePin, LOW); // sturing gecentreerd} void loop () {// Haal het volgende commando op van seriële bluetooth (voeg 1 byte toe voor de laatste 0) char input [INPUT_SIZE + 1]; // array van type char (C-string) met null-termination (https://www.arduino.cc/en/Reference/String) byte size =Serial.readBytesUntil('\n', input, INPUT_SIZE); // lees Serieel tot nieuwe regel of buffer vol of time-out is // Voeg de laatste 0 toe om de C-string invoer [grootte] =0 te beëindigen; // Lees commando dat een C-string is van de vorm:"RC,RCsteering,RCspeed,\n\0" (eindigt met een nieuw regelteken en een null) char* command =strtok(input, ","); // negeer commando voor nu (RC voor Remote Control is voorlopig het enige commando dat door de app wordt verzonden) char* RCsteering =strtok(NULL, ","); // daarna komt RCsteering in het bereik:-100 (links).. 0 .. 100 (rechts) char* RCspeed =strtok(NULL, ","); // daarna komt RCspeed die in het bereik ligt:​​-100 (volledige snelheid achteruit).. 0 .. 100 (volledige snelheid vooruit) int iRCsteering =atoi(RCsteering); // convert string RCsteering naar integer iRCsteering int iRCspeed =atoi(RCspeed); // convert string RCspeed naar integer iRCspeed // Stel motor- en servobesturingsvariabelen in als (iRCsteering> 0) steeringDirection =1; // sla rechtsaf als iRCsteering =1..100 else steeringDirection =0; // sla linksaf als iRCsteering =-100..0 steering =int(2.55*abs(iRCsteering)); // Servopositie 0..255 gebaseerd op commando 0..100 indien (iRCspeed> 0) motorDirection =1; // Zet de auto vooruit als iRCspeed =1..100 else motorDirection =0; // Zet de auto in zijn achteruit als iRCspeed =-100..0 motorSpeed ​​=int(2.55*abs(iRCspeed)); // Stel snelheid 0..255 in op basis van commando 0..100 SetMotorControl(); // pas de richting en snelheid van de motor aan }void SetMotorControl()/*L293 logica:EN1,2 1A 2A HHL Motor draait naar links (Forward; motorDirection ==1) HLH Motor draait naar rechts (Reverse; motorDirection ==0) EN3,4 3A 4A HHL Servo draait naar links (steeringDirection ==0) HLH Servo draait naar rechts (steeringDirection ==1)Motorsnelheid:PWM-signaal aan EN1,2 (490 Hz; digitale uitgangswaarde 0..255 voor motorSpeed)Servopositie:PWM-signaal aan EN3,4 (490 Hz; digitale uitgangswaarde 0..255 voor positie; 0 is recht vooruit)*/{ if (motorDirection ==1) //Forward { digitalWrite(controlPin1A, HIGH); digitalWrite (controlPin2A, LAAG); } else //Reverse {digitalWrite(controlPin1A, LOW); digitalWrite(controlPin2A, HOOG); } analogWrite (ENablePin, motorSpeed); // Snelheid als (steeringDirection ==0) // Links {digitalWrite (controlPin3A, HIGH); digitalWrite (controlPin4A, LAAG); } else //Right {digitalWrite(controlPin3A, LOW); digitalWrite(controlPin4A, HOOG); } analogWrite(servoENablePin, stuur); //Servopositie}