Arduino-robot met PS2-controller (PlayStation 2-joystick)

Over dit project

In deze tutorial laat ik je zien hoe je een draadloze PlayStation 2 (PS2)-joystick gebruikt om een ​​robottank te besturen. In de kern van dit project werd een Arduino Uno-bord gebruikt. Het ontvangt opdrachten van de draadloze controller en stelt de snelheid van de motoren in. Andere ontwikkelborden kunnen ook worden gebruikt (NodeMCU, Firebeetle, enz.), en de principes die in deze tutorial worden gepresenteerd, kunnen worden toegepast op andere modellen van robots en gadgets.

Ik heb eerder een door Blynk bestuurde robottank ontworpen. Het maakt verbinding met een Wi-Fi-netwerk en ontvangt opdrachten van de Blynk-server. Een smartphone met de Blynk-app werd gebruikt als afstandsbediening en er werden verschillende invoermethoden gebruikt:drukknoppen, schuifbalken en zelfs de versnellingsmeter van de smartphone. U kunt hier meer over dit project vinden:https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198

Ik heb ook wat geëxperimenteerd met spraakopdrachten. Het kan handig zijn als je een robot op afstand wilt besturen zonder je handen te gebruiken, of als je hem toegankelijk wilt maken voor iemand met beperkte bewegingen. Denk bijvoorbeeld aan een spraakgestuurde robotrolstoel. Er werd een doe-het-zelf-robotkit gebruikt, samen met enkele van mijn favoriete tools:Adafruit.io, IFTTT en Arduino IDE. Volledige instructies hier:

https://www.hackster.io/igorF2/wi-fi-voice-control-robot-using-google-assistant-79802c

U kunt verschillende kits gebruiken of zelfs uw eigen robots ontwerpen met eenvoudige materialen, zonder dat u complexe hulpmiddelen zoals 3D-printers en lasersnijmachines nodig hebt. Je kunt een voorbeeld vinden in een van mijn vorige tutorials:

https://www.hackster.io/igorF2/widc-wi-fi-control-fpv-robot-8f1e09

Stap 1:Gereedschappen en materialen

In dit project zijn de volgende tools gebruikt:

• Soldeerbout en draad (link/link). De DC-motoren werden al geleverd met draden die aan de klemmen waren gesoldeerd... Maar deze zal uiteindelijk breken en mogelijk moet u hem opnieuw solderen. Overweeg dus om een ​​goede soldeerbout en draad in de buurt te hebben.
• EVA-schuimplaat (of ander niet-geleidend materiaal). Het robotchassis dat ik in dit project heb gebruikt, is gemaakt van aluminium en op deze metalen onderdelen zijn printplaten geïnstalleerd. Ik heb een laag schuimfolie tussen de planken en de metalen plaat gebruikt om mogelijke kortsluitingen te voorkomen.
• Dubbelzijdige tape . Het werd gebruikt voor het lijmen van de schuimplaten op de printplaten en voor de installatie van de H-Bridge-module.
• Schaar , voor het snijden van enkele rechthoeken van schuimfolie.

Ik heb de volgende hardware-onderdelen voor mijn project gebruikt:

• Ontwikkelingsbord gebaseerd op Arduino Uno (link/link/link/link). Het wordt gebruikt als de hoofdcontroller van de robot. Het is heel gemakkelijk te gebruiken en te programmeren met Arduino IDE, ideaal voor beginners op het gebied van elektronica en programmeren.

• L298N tweekanaals H-brugmodule (link/link/link/link). Met deze module kunnen de 3,3V-signalen van de Wemos (of een Arduino) worden versterkt tot de 12V die nodig is voor de motoren.

• DIY Robot Chassis Tank (koppeling). Deze geweldige kit bevat alles wat je nodig hebt om een ​​tank te bouwen:twee gelijkstroommotoren, tandwielen, rupsbanden, bouten, moeren, enz. Het wordt al geleverd met het gereedschap dat nodig is om het chassis te monteren, wat geweldig is voor beginners!

• PS2 draadloze afstandsbediening (koppeling). Deze videogamecontroller kan draadloos opdrachten naar een ontvanger sturen, die via seriële communicatie kan worden gekoppeld aan een microcontroller.

• 18650 3.7V batterijen (x3) (link/link). Ik heb het hele circuit van stroom voorzien. Deze tank maakt gebruik van 12V motoren. Ik heb drie 3.7V-batterijen in serie gebruikt om ze van stroom te voorzien.

• 3S 18650 batterijhouder (link/link/link). Het kan drie 18650-batterijen in serie bevatten en kan eenvoudig aan de achterkant van de tank worden bevestigd.

• 18650 batterijlader (link/link). Je batterijen raken uiteindelijk leeg. Wanneer dat gebeurt, komt een acculader u te hulp.
• Truien (link/link). Ik heb 6 man-vrouw jumpers gebruikt voor signalen tussen de h-brug en de Wemos, en 2 man-man jumpers voor 5V en Gnd. Mogelijk hebt u meer nodig als u van plan bent enkele sensoren toe te voegen.
• Type-B USB-kabel . Deze heb je nodig voor het uploaden van je code. De meeste boards hebben al een eigen kabel.

De links hierboven zijn slechts een suggestie van waar je de items kunt vinden die in deze tutorial worden gebruikt (en misschien ondersteunen ze mijn toekomstige tutorials). Zoek ze gerust ergens anders en koop ze bij uw favoriete lokale of online winkel.

Stap 2:De robot in elkaar zetten

Het eerste deel van dit project was de montage van de robotstructuur.

In eerdere projecten heb ik de structuur van mijn eigen robot ontwikkeld, met behulp van gemakkelijk toegankelijke materialen (zonder de noodzaak van complexe gereedschappen, 3D-printers of lasersnijmachines). Je kunt dit project vinden via de onderstaande link:

https://www.hackster.io/igorF2/widc-wi-fi-control-fpv-robot-8f1e09

Later besloot ik een kans te geven op een robotkit die ik in een online winkel had gekocht. Een link naar het robotchassis vind je op de volgende link:http://bit.ly/2ycI8fP. Als je op zoek bent naar een kit, denk ik dat het een goede optie is! Ik heb het in twee andere tutorials gebruikt, zoals je kunt zien op de onderstaande links:

https://www.hackster.io/igorF2/wi-fi-controlled-robot-using-wemos-d1-esp8266-and-blynk-464198

https://www.hackster.io/igorF2/wi-fi-voice-control-robot-using-google-assistant-79802c

In eerste instantie leek het erop dat de montage ingewikkeld zou zijn of dat ik problemen zou tegenkomen zoals het ontbreken van onderdelen (gezien het aantal onderdelen waaruit de kit bestaat). Maar deze kit heeft me echt verrast! Alle stukken lijken mij van goede kwaliteit en verschillende reserveonderdelen vergezelden de kit. Dus een schroef die onder de werkbank verloren gaat, maakt het niet onmogelijk om je project uit te voeren, wat ik uitstekend vond (vooral na het verliezen van een paar schroeven).

Een ander positief punt is dat al het gereedschap dat nodig is om de robot te monteren in de kit zit (een paar inbussleutels en de schroevendraaier). Ik geloof dat dit de kit uitstekend maakt voor beginners die niet veel gereedschap hebben!

Als negatief aspect zou ik het gebrek aan documentatie willen benadrukken. De monteur van de robot

ual (een spreadsheetbestand in het Chinees) is niet erg gebruiksvriendelijk en er zijn niet veel tutorials online voor die tank. En dus besloot ik het proces van het assembleren van mijn robot in de video hierboven te documenteren! Een ander aandachtspunt betreft het materiaal van de robotconstructie. De basis is volledig van aluminium, wat kortsluiting kan veroorzaken als de pinnen van de printplaten het frame raken.

Er zijn andere online kits die u kunt gebruiken. Je kunt zelfs je eigen structuur maken, zoals ik hieronder heb beschreven.

Stap 3:Bedrading van het circuit

Op de achterkant van de robot werd een powerpack van drie 18650-batterijen geïnstalleerd. Het levert 11,1 V (3 x 3,7 V) aan de robot. Dat is genoeg om de 12V DC-motoren van stroom te voorzien.

Voor de aansturing van de motoren werd een L298N tweekanaals H-brug gebruikt. Het ontvangt enkele 5V-signalen van het Arduino-bord en levert hogere spanningen voor de motoren. Het zorgt er ook voor dat de motoren in beide richtingen kunnen draaien, afhankelijk van de combinatie van die ingangssignalen.

Elk apparaat was aangesloten volgens het schema.

Volgt een lijst met de pinnen die u moet aansluiten:

Arduino Uno-ingangen/-uitgangen:

• Digitale pin 3 => H-Bridge ENA-pin
• Digitale pin 5 => H-Bridge IN1 pin
• Digitale pin 4 => H-Bridge IN2-pin
• Digitale pin 8 => H-Bridge IN3-pin
• Digitale pin 7 => H-Bridge IN4-pin
• Digitale pin 6 => H-Bridge ENB-pin
• 5V-pin => H-Bridge 5V-pin
• Gnd-pin => H-brug Gnd-pin
• Digitale pin 10 => PS2-ontvanger pin 6
• Digitale pin 11 => PS2-ontvanger pin 2
• Digitale pin 12 => PS2-ontvanger pin 1
• Digitale pin 13 => PS2-ontvanger pin 7
• 3,3V pin => PS2-ontvanger pin 5
• Gnd pin => PS2-ontvanger pin 4

H-Bridge ingangen/uitgangen:

• ENA pin => Arduino digitale pin 3
• IN1 pin => Arduino digitale pin 5
• IN2 pin => Arduino digitale pin 4
• IN3-pin => Arduino digitale pin 8
• IN4 pin => Arduino digitale pin 7
• ENB-pin => Arduino digitale pin 6
• 5V-pin => Arduino 5V-pin
• Gnd-pin => Arduino Gnd-pin
• Gnd pin => Negatieve draad accupack
• 12V pin => Positieve draad accupack
• OUT1 => Negatieve draad motor rechts
• OUT2 => Positieve draad rechts motor
• OUT3 => Positieve draad linker motor
• OUT4 => Negatieve draad linker motor

PS2-ontvanger:

• Pin 1 (data) => Arduino digitale pin 12
• Pin 2 (opdracht) => Arduino digitale pin 11
• Pin 4 (aarde) => Arduino Gnd-pin
• Pin 5 (voeding) => Arduino 3.3V-pin
• Pin 6 (let op) => Arduino digitale pin 10
• Pin 7 (klok) => Arduino digitale pin 13

Stap 4:Arduino IDE instellen

Voor dit project heb ik Arduino IDE gebruikt voor het programmeren van het Arduino-bord.

1. Download en installeer Arduino IDE nieuwste versie

Je kunt de nieuwste versie voor Windows, Linux of MAC OSX vinden op de Arduino-website:https://www.arduino.cc/en/main/software

Download het gratis, installeer het op uw computer en start het.

2. De bibliotheken toevoegen

In dit project gebruik ik de Arduino PS2X-bibliotheek.

Download de bibliotheek op https://github.com/madsci1016/Arduino-PS2X. Pak het bestand uit en kopieer de mappen naar Arduino IDE-bibliotheken/tools-mappen.

............

Nu uw ontwikkelomgeving klaar is, gaan we verder met de volgende stap!

Stap 5:PS2 draadloze controllerbibliotheek uitgelegd

Een PS2 draadloze controller is een geweldig hulpmiddel voor je robotica-projecten. Het heeft ongelooflijk veel knoppen:20 digitale drukknoppen en 2 analoge sticks. Op deze manier zijn er eindeloze mogelijkheden om je robot te besturen.

Ik heb de PS2X-bibliotheek van Bill Porter (https://github.com/madsci1016/Arduino-PS2X) gebruikt om de controller op een Arduino Uno-bord aan te sluiten.

Het definieert een PS2X-klasse voor de controller, die enkele methoden bevat voor het lezen van analoge en digitale invoer van de joystick. Een object voor deze klasse wordt gemaakt met behulp van de volgende code (voor of tijdens de installatie):

PS2X ps2x;  

Nadat het object is gedefinieerd, moet het worden gekoppeld aan Arduino I/O-pinnen met behulp van de volgende functie:

fout =ps2x.config_gamepad(klok,opdracht,aandacht,gegevens, druk?, rumble?);  

Deze functie kan enkele fouten retourneren als er iets mis is met de verbindingen of met de controller zelf.

De belangrijkste functies van de bibliotheek zijn die voor het lezen van digitale en analoge ingangen. Voor het lezen en digitale invoer wordt de volgende methode gebruikt:

ps2x.Button(knop);  

In welke knop is de naam van de te lezen knop. Elke knop is als volgt toegewezen:

Richtingsknoppen:

• PSB_PAD_UP =D-pad omhoog-knop;
• PSB_PAD_DOWN =D-pad omlaag-knop;
• PSB_PAD_LEFT =D-pad linkerknop
• PSB_PAD_RIGHT =D-pad rechterknop

Actieknoppen:

• PSB_GREEN of PSB_TRIANGLE =groene driehoekige knop
• PSB_RED of PSB_CIRCLE =rode cirkelknop
• PSB_BLUE of PSB_CROSS =blauwe x-knop
• PSB_PINK of PSB_SQUARE =​​roze vierkante knop

Triggers:

• PSB_L1 =linker triggerknop 1
• PSB_R1 =triggerknop rechts 1
• PSB_L2 =linker triggerknop 2
• PSB_R2 =triggerknop rechts 2

Stokken:

• PSB_L3 =linker joystick-drukknop (ja, je kunt de stick indrukken als een drukknop)
• PSB_R3 =rechter joystick-drukknop

Menu:

• PSB_SELECT =selectieknop
• PSB_START =startknop

Gebruik de volgende methode om de analoge waarde (met whill be-converter in een geheel getal tussen 0 en 255) van de sticks te lezen:

ps2x.Analog(stick_axis);  

In welke stick_axis vertegenwoordigt de stick en de richting die moet worden gelezen, als volgt:

• PSS_LY =y-positie van linker joystick
• PSS_LX =x-positie van linker joystick
• PSS_RY =y-positie van rechter joystick
• PSS_RX =x-positie van rechter joystick

Met die basisfuncties ben je klaar om de PS2-controller op je project te gebruiken! Bij de volgende stappen laat ik enkele Arduino-schetsvoorbeelden zien die deze knoppen combineren!

Stap 6:Schets #1 - Dpad-knoppen

Oude videogames, zoals SEGA Master System en Mega Drive en Nintendo SNES, hadden geen krachtgevoelige knoppen. De richtingsknoppen waren alleen aan/uit-knoppen. Voor dit eerste voorbeeld wilde ik het soort bedieningselementen nabootsen dat je zou hebben in oude videogames van die consoles.

Voor deze eerste schets heb ik Dpad-knoppen gebruikt als invoer voor de robot. Elke knop werd door de robot gebruikt om een ​​van de basisbewegingen uit te voeren:vooruit, naar rechts, naar links of naar achteren.

Die knoppen hebben binaire uitgangen. Op deze manier begrijpt de microcontroller alleen dat de knoppen zijn ingedrukt, maar niet hoe hard ze zijn ingedrukt. Op deze manier zullen de motoren, zodra er op een bepaalde knop wordt geklikt, op volle snelheid draaien.

Als je alles volgens mijn schema hebt aangesloten, heb je de volgende uitgangen:

• PSB_PAD_UP =vooruit
• PSB_PAD_DOWN =ga terug
• PSB_PAD_LEFT =sla linksaf
• PSB_PAD_RIGHT =sla rechtsaf

Zoals ik al eerder vertelde, zal de motor met een vaste snelheid bewegen. Bij het naar links of rechts draaien zullen motoren in tegengestelde richting draaien, zodat de robot om zijn as zal draaien.

Arduino-code:

Download de code en open deze op Arduino IDE. Als u dezelfde pinout gebruikt als ik, hoeft u waarschijnlijk niets aan de code te wijzigen (hoewel dit misschien nodig is als de oriëntatie van de motoren anders is

Om de code te uploaden, selecteert u het 'Arduino/Genuino Uno'-bord, selecteert u de juiste COM-poort, sluit u het bord aan op de USB-poort van uw computer en uploadt u de code.
Nadat het uploaden is voltooid, koppelt u de USB-kabel los en plaatst u de batterijen. De code begint te lopen en het Arduino-bord verbindt automatisch de PS2-joystick. Open de seriële monitor bij het eerste gebruik en controleer de status van de verbinding. Als het niet lukt om verbinding te maken met de joystick, moet u iets doen:

• Reset het Arduino Uno-bord. Probeer het meerdere keren (voor mij werkt het meestal na de derde reset);
• Controleer of de joystick is ingeschakeld (en met opgeladen batterijen). De ontvanger heeft enkele LED's die aangeven of de joystick is gekoppeld. Controleer ook of Arduino's RX- en TX-pinnen knipperen als het nieuwe opdrachten ontvangt (en de status op de seriële poort bijwerkt);
• Controleer de verbindingen... er kan iets mis zijn in de jumpers tussen de componenten.

Code uitgelegd:

In dit project hoefde ik alleen de bibliotheek PS2X_lib.h te gebruiken. I wordt toegevoegd aan het begin van de code.

#include   

Definieer de pinnen van de Arduino die op de h-bridge is aangesloten. Als je dezelfde connecties gebruikt als ik, heb je de volgende configuratie. Als je ervoor kiest om andere pinnen te gebruiken, werk dan dit deel van de code bij.

// Deze worden gebruikt om de richting van de brugbestuurder in te stellen. #define ENA 3 //ENA #define MOTORA_1 4 //IN3 #define MOTORA_2 5 //IN4 #define MOTORB_1 8 //IN1 #define MOTORB_2 7 //IN2 #define ENB 6 //ENB  

Sommige globale variabelen zijn gedeclareerd vóór de installatie (p2sx , fout , typ en trillen ). De eerste is een instantie van de PS2X-klasse. Foutstatus tijdens de verbinding wordt opgeslagen op fout geheel getal. Type en trillen geeft het type controller aan (DualShock- of GuitarHero-controller) en of deze hoort te trillen bij een bepaald commando.

Het eerste wat ik deed tijdens de installatie was om de status van de I/O-pinnen (als uitvoer) te configureren en de activeringspinnen op LAAG in te stellen. Op deze manier schakelt u beide motoren uit bij het opstarten en beweegt de robot niet willekeurig terwijl hij wacht op de rest van de code.

// Configureer uitgangspinnen pinMode (ENA, OUTPUT); pinMode(MOTORA_1, UITGANG); pinMode (MOTORA_2, UITGANG); pinMode (ENB, UITGANG); pinMode(MOTORB_1, UITGANG); pinMode (MOTORB_2, UITGANG); // Schakel beide motoren digitalWrite (ENA,0) uit; digitalWrite(ENB,0);  

Toen begon ik met seriële poortcommunicatie (handig voor het debuggen van de code). Kies een geschikte baudrate en stel dezelfde snelheid in op de seriële monitor.

// Start seriële communicatie Serial.begin(57600);  

Configureer tot slot het ps2x-object met de pinnen van de Arduino die waren aangesloten op de joystickontvanger (respectievelijk klok, commando, aandacht en gegevens). Het kan een fout retourneren (weer te geven op de seriële monitor). Het type controller wordt ook weergegeven (hoewel je waarschijnlijk al weet welk type controller je op dit moment in handen hebt :D).

fout =ps2x.config_gamepad(13,11,10,12, true, true); // pinnen en instellingen instellen:GamePad (klok, commando, aandacht, gegevens, Drukken?, Rumble?) Controleer op fouten // Controleer op fouten if (error ==0) {Serial.println ("Found Controller, succesvol geconfigureerd" ); } else if(error ==1) Serial.println("Geen controller gevonden, controleer de bedrading of reset de Arduino"); else if(error ==2) Serial.println("Controller gevonden maar geen opdrachten accepteren"); else if(error ==3) Serial.println("Controller die weigert naar de Drukmodus te gaan, ondersteunt deze mogelijk niet."); // Controleer het type controllertype =ps2x.readType(); switch (type) { case 0:Serial.println ("Onbekend type controller"); pauze; geval 1:Serial.println ("DualShock-controller gevonden"); pauze; geval 2:Serial.println ("GuitarHero-controller gevonden"); pauze; }  

Tijdens de hoofdlus leest de Arduino elke D-pad-knop (UP, DOWN, LEFT en RIGTH) en stelt de verschillende waarden voor de output-pinnen in om de wielen te verplaatsen. Na een korte vertraging wordt een nieuwe lus gestart.

Het volgende gedeelte laat zien hoe de robot vooruit kan worden bewogen als de OMHOOG-knop werd ingedrukt. MOTORA_1 en MOTORA_2 pinnen bepalen de draairichting voor motor A. ENA bepaalt of de beweging is ingeschakeld of niet (motor AAN/UIT). Merk op dat het een "analoge" uitgang is (eigenlijk een PWM-uitgang). De waarde moet tussen 0 en 1023 liggen. Dit zal de PWM moduleren en de gemiddelde spanning aan de uitgang van de h-brug veranderen (tussen 0 en 12V). Als de gemiddelde spanning te laag is, kan de motor helemaal niet bewegen.

// BEWEEG VOORUIT if(ps2x.Button(PSB_PAD_UP)) {digitalWrite(MOTORA_1,LOW); digitalWrite (MOTORA_2, HOOG); digitalWrite(MOTORB_1,HOOG); digitalWrite(MOTORB_2,LOW); analoogWrite(ENB, 1023); analoogWrite(ENA, 1023); Serial.println ("Ga vooruit"); }  

*Ik gebruikte PWM-uitgangen voor de ENA- en ENB-pinnen. Op deze manier zou 1023 een puls vertegenwoordigen met de grootste lengte (pin altijd aan) en 0 de afwezigheid van pulsen (pin altijd uit). Als hier een andere (kleinere) waarde wordt gebruikt, wordt verwacht dat de motoren langzamer draaien, omdat de gemiddelde spanning in hun klemmen kleiner zal zijn.

Stap 7:Schets #2 - Analoge stick en digitale knoppen (L2 en R2)

Op een gegeven moment gebruikten alle consoles joysticks met twee analoge sticks. Die nieuwe inputs maakten krachtgevoelige inputs mogelijk die acties met variabele snelheid creëerden en populair werden in alle soorten videogames.

In dit tweede voorbeeld wilde ik een analoge schakelaar gebruiken voor het sturen van de tank, en een paar o drukknoppen als gaspedaal en remmen/achteruit. Dit soort configuratie is erg populair in veel racegames, zoals Mario Kart bijvoorbeeld. Druk op de R2-knop voor versnelling van de tank, L2 voor achteruit en stel de bewegingsrichting in op basis van de x-positie van de linker joystick.

Het soort robotkit dat ik heb gebruikt, heeft niet veel traagheid (als de spanning op de motoren is ingesteld op 0V, blijft deze een tijdje niet bewegen). Op deze manier was het niet nodig om een ​​commando te definiëren om de robot te remmen.

Het grootste deel van de code is al uitgelegd in de vorige stap. Een verschil is dat ik twee variabelen heb gedefinieerd die de snelheid van elke motor opslaan (van 0 tot 1023).

int motor_right_speed =0;
int motor_left_speed =0;  

In de hoofdlus leest de Arduino de x-positie van de linker joystick. Het krijgt een waarde tussen 0 en 255 en brengt het in kaart tussen -1023 en 1023.

Deze waarde wordt opgeteld (of afgetrokken) bij de snelheid van elke motor, om een ​​verschil te creëren tussen de snelheid van elke baan en de robot naar links of rechts te laten draaien.

int nJoyL =ps2x.Analog(PSS_LX); // lees linker joystick nJoyL =map (nJoyL, 0, 255, 1023, -1023); motor_right_speed =1023; motor_links_snelheid =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; }  

Als de R2-knop wordt ingedrukt, gaat de tank vooruit. Op deze manier stelt de Arduino de juiste waarden in voor de motorpinnen. ENA en ENB creëren 'analoge' uitgangen voor elke motor, met een waarde die evenredig is aan de gewenste snelheid voor elke motor (gebaseerd op de x-positie van de linker joystick).

L2 zal iets soortgelijks doen, maar de richting van de motor omkeren.

if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite (MOTORA_2, HOOG); digitalWrite(MOTORB_1,HOOG); digitalWrite(MOTORB_2,LOW); analogWrite(ENA, motor_right_speed); analogWrite (ENB, motor_links_snelheid); } if(ps2x.Button(PSB_L2)) {digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENA, motor_right_speed); analogWrite (ENB, motor_links_snelheid); } if(!ps2x.Button(PSB_L2) ​​&&!ps2x.Button(PSB_R2)) { analogWrite(ENA, 0); analoogWrite(ENB, 0); }  

Als geen van de knoppen is ingedrukt, worden de motoren uitgeschakeld.

Stap 8:Sketch #3 - Analoge sticks links en rechts (differentiële aandrijving)

Dit is mijn favoriete manier om de tank te besturen (hoewel het niet optimaal is qua middelen)! Het geeft me het gevoel dat ik een echte grote machine met beide handen bestuur!

In deze code heb ik beide sticks gebruikt om de richting en snelheid van elk nummer in te stellen. De linker joystick zal het linker spoor besturen en de rechter joystick zal het rechter spoor besturen.

De code is bijna hetzelfde als eerder beschreven. Maar deze keer wilde ik de y-positie van beide sticks lezen:

int nJoyL =ps2x.Analoog(PSS_LY); // lees linker joystick int nJoyR =ps2x.Analog (PSS_RY); // lees rechter joystick nJoyL =map (nJoyL, 0, 255, 1023, -1023); nJoyR =kaart(nJoyR, 0, 255, -1023, 1023);  

Afhankelijk van de positie van de stick, stelt de code de digitale pinnen in om de richting van elke motor in te stellen.

Ik gebruikte een vaste waarde bij inschakelen (1023), maar ik zou een variabele waarde gebruiken op basis van de werkelijke waarde van de analoge stick. Ik heb een dode band (+-50) gedefinieerd waarin de microcontroller de motoren zal uitschakelen.

// Voer bewegingen uit op basis van beide analoge sticks if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); analoogWrite(ENA, 1023); } if(nJoyR<-50) { digitalWrite(MOTORA_1,LOW); digitalWrite (MOTORA_2, HOOG); analoogWrite(ENA, 1023); } if (abs(nJoyR)<50) { analogWrite(ENA, 0); }  

Stap 9:Sketch #4 - Alleen linker analoge stick

In deze laatste Sketch-app heb ik een enkele joystick gebruikt om de robot te besturen. Het is optimaal in termen van gebruik van bronnen (je hebt nog veel knoppen over om verschillende acties te configureren), maar het is vrij moeilijk om het te begrijpen.

De snelheid van elk spoor wordt bepaald afhankelijk van de x- en y-posities van de joystick. Op deze manier is het mogelijk om op elke baan verschillende snelheden toe te passen en de robot met verschillende snelheden/richtingen te verplaatsen. De hier gebruikte code is afgeleid van de volgende zelfstudie. Check it out!

https://www.impulseadventure.com/elec/robot-differential-steering.html

Stap 10:laatste overwegingen

Ik heb veel energie gestoken in dit project, om het zo duidelijk en leerzaam mogelijk te maken. Als je het leuk vond, vergeet dan niet om het te 'liken' en te 'delen'. Uw steun is erg belangrijk voor mij! :D

Als je mijn tutorials nog steeds niet volgt, kijk dan eens naar die andere tutorials over robotica! Ik hoop dat je ze leuk vindt!

https://www.hackster.io/igorF2/joy-robot-robo-da-alegria-bba54f

https://www.hackster.io/igorF2/widc-wi-fi-control-fpv-robot-8f1e09

https://www.hackster.io/igorF2/nunchuk-controlled-robotic-arm-with-arduino-b1c0fa

https://www.hackster.io/igorF2/wi-fi-browser-controlled-robotic-arm-89b63d

Overweeg om mijn toekomstige projecten te steunen met een kleine Bitcoin-donatie! :D

BTC-stortingsadres:1FiWFYSjRaL7sLdr5wr6h86QkMA6pQxkXJ

Code

• Schets #1
• Schets #2
• Schets #3
• Schets #4

Schets #1Arduino

// PS2 Tank door Igor Fonseca @2019// Bestuurt een robottank met behulp van een PS2-joystick, met behulp van D-pad-knoppen// gebaseerd op een voorbeeld met behulp van de PS2X-bibliotheek van Bill Porter 2011// Alle bovenstaande tekst moet worden opgenomen in elke herdistributie.// include libraries#include // Deze worden gebruikt om de richting van de bridge driver in te stellen.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4 #define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBPS2X ps2x; // maak PS2 Controller Class//op dit moment ondersteunt de bibliotheek GEEN hot-pluggable controllers, wat betekent // je moet altijd ofwel je Arduino opnieuw opstarten nadat je de controller hebt aangesloten, //of config_gamepad(pins) opnieuw aanroepen nadat je de controller hebt aangesloten. int-fout =0; byte type =0; byte trillen =0; ongeldige setup () {// Configureer output pinnen pinMode (ENA, OUTPUT); pinMode(MOTORA_1, UITGANG); pinMode (MOTORA_2, UITGANG); pinMode (ENB, UITGANG); pinMode(MOTORB_1, UITGANG); pinMode (MOTORB_2, UITGANG); // Schakel beide motoren digitalWrite uit (ENA,0); digitalWrite(ENB,0); // Start seriële communicatie Serial.begin (57600); error =ps2x.config_gamepad(13,11,10,12, waar, waar); // stel pinnen en instellingen in:GamePad (klok, commando, aandacht, gegevens, Drukken?, Rumble?) Controleer op fouten // Controleer op fouten if (error ==0) {Serial.println ("Found Controller, succesvol geconfigureerd" ); } else if(error ==1) Serial.println("Geen controller gevonden, controleer de bedrading of reset de Arduino"); else if(error ==2) Serial.println("Controller gevonden maar geen opdrachten accepteren"); else if(error ==3) Serial.println("Controller die weigert naar de modus Drukken te gaan, ondersteunt deze mogelijk niet."); // Controleer het type controllertype =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); pauze; case 1:Serial.println("DualShock Controller Found"); pauze; case 2:Serial.println("GuitarHero Controller Found"); pauze; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller // Perform movements based on D-pad buttons // MOVE FORWARD if(ps2x.Button(PSB_PAD_UP)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move forward"); } // TURN RIGHT if(ps2x.Button(PSB_PAD_RIGHT)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn right"); } // TURN LEFT if(ps2x.Button(PSB_PAD_LEFT)){ digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Turn left"); } // MOVE BACK if(ps2x.Button(PSB_PAD_DOWN)){ digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); analogWrite(ENA, 1023); Serial.println("Move back"); } if (!ps2x.Button(PSB_PAD_DOWN) &&!ps2x.Button(PSB_PAD_UP) &&!ps2x.Button(PSB_PAD_RIGHT) &&!ps2x.Button(PSB_PAD_LEFT)) { analogWrite(ENB, 0); analogWrite(ENA, 0); } vertraging(50); } }

Sketch #2Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); pauze; case 1:Serial.println("DualShock Controller Found"); pauze; case 2:Serial.println("GuitarHero Controller Found"); pauze; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LX); // read left stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); int motor_right_speed =1023; int motor_left_speed =1023; if (nJoyL <0) { motor_right_speed =motor_right_speed + nJoyL; } if (nJoyL> 0) { motor_left_speed =motor_left_speed - nJoyL; } if(ps2x.Button(PSB_R2)) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(ps2x.Button(PSB_L2)) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENA, motor_right_speed); analogWrite(ENB, motor_left_speed); } if(!ps2x.Button(PSB_L2) &&!ps2x.Button(PSB_R2)) { analogWrite(ENA, 0); analogWrite(ENB, 0); } vertraging(50); } }

Sketch #3Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using D-pad buttons// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include // These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBPS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); pauze; case 1:Serial.println("DualShock Controller Found"); pauze; case 2:Serial.println("GuitarHero Controller Found"); pauze; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyL =ps2x.Analog(PSS_LY); // read left stick int nJoyR =ps2x.Analog(PSS_RY); // read right stick nJoyL =map(nJoyL, 0, 255, 1023, -1023); nJoyR =map(nJoyR, 0, 255, -1023, 1023); // Perform movements based on both analog sticks if(nJoyR>50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); analogWrite(ENA, 1023); } if(nJoyR<-50) { digitalWrite(MOTORA_1,LOW); digitalWrite(MOTORA_2,HIGH); analogWrite(ENA, 1023); } if (abs(nJoyR)<50) { analogWrite(ENA, 0); } if(nJoyL>50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); analogWrite(ENB, 1023); } if(nJoyL<-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2,HIGH); analogWrite(ENB, 1023); } if (abs(nJoyL)<50) { analogWrite(ENB, 0); } vertraging(50); } }

Sketch #4Arduino

// PS2 Tank by Igor Fonseca @2019// Controls a robotic tank using a PS2 joystick, using left analog stick// based on an example using the PS2X library by Bill Porter 2011// All text above must be included in any redistribution.// include libraries#include  //for v1.6// These are used to set the direction of the bridge driver.#define ENA 3 //ENA#define MOTORA_1 4 //IN3#define MOTORA_2 5 //IN4#define MOTORB_1 8 //IN1#define MOTORB_2 7 //IN2#define ENB 6 //ENBint motor_right_speed =0;int motor_left_speed =0;PS2X ps2x; // create PS2 Controller Class//right now, the library does NOT support hot pluggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error =0; byte type =0;byte vibrate =0;void setup(){ // Configure output pins pinMode(ENA, OUTPUT); pinMode(MOTORA_1, OUTPUT); pinMode(MOTORA_2, OUTPUT); pinMode(ENB, OUTPUT); pinMode(MOTORB_1, OUTPUT); pinMode(MOTORB_2, OUTPUT); // Disable both motors digitalWrite(ENA,0); digitalWrite(ENB,0); // Start serial communication Serial.begin(57600); error =ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings:GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error // Check for error if(error ==0){ Serial.println("Found Controller, configured successful"); } else if(error ==1) Serial.println("No controller found, check wiring or reset the Arduino"); else if(error ==2) Serial.println("Controller found but not accepting commands"); else if(error ==3) Serial.println("Controller refusing to enter Pressures mode, may not support it."); // Check for the type of controller type =ps2x.readType(); switch(type) { case 0:Serial.println("Unknown Controller type"); pauze; case 1:Serial.println("DualShock Controller Found"); pauze; case 2:Serial.println("GuitarHero Controller Found"); pauze; }}// Main loopvoid loop(){ if(error ==1) //skip loop if no controller found return; else { //DualShock Controller ps2x.read_gamepad(false, vibrate); // disable vibration of the controller int nJoyX =ps2x.Analog(PSS_LX); // read x-joystick int nJoyY =ps2x.Analog(PSS_LY); // read y-joystick nJoyX =map(nJoyX, 0, 255, -1023, 1023); nJoyY =map(nJoyY, 0, 255, 1023, -1023); // OUTPUTS int nMotMixL; // Motor (left) mixed output int nMotMixR; // Motor (right) mixed output // CONFIG // - fPivYLimt :The threshold at which the pivot action starts // This threshold is measured in units on the Y-axis // away from the X-axis (Y=0). A greater value will assign // more of the joystick's range to pivot actions. // Allowable range:(0..+127) float fPivYLimit =1023.0; // TEMP VARIABLES float nMotPremixL; // Motor (left) premixed output float nMotPremixR; // Motor (right) premixed output int nPivSpeed; // Pivot Speed float fPivScale; // Balance scale between drive and pivot // Calculate Drive Turn output due to Joystick X input if (nJoyY>=0) { // Forward nMotPremixL =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); nMotPremixR =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; } else { // Reverse nMotPremixL =(nJoyX>=0)? (1023.0 - nJoyX) :1023.0; nMotPremixR =(nJoyX>=0)? 1023.0 :(1023.0 + nJoyX); } // Scale Drive output due to Joystick Y input (throttle) nMotPremixL =nMotPremixL * nJoyY/1023.0; nMotPremixR =nMotPremixR * nJoyY/1023.0; // Now calculate pivot amount // - Strength of pivot (nPivSpeed) based on Joystick X input // - Blending of pivot vs drive (fPivScale) based on Joystick Y input nPivSpeed =nJoyX; fPivScale =(abs(nJoyY)>fPivYLimit)? 0.0 :(1.0 - abs(nJoyY)/fPivYLimit); // Calculate final mix of Drive and Pivot nMotMixL =(1.0-fPivScale)*nMotPremixL + fPivScale*( nPivSpeed); nMotMixR =(1.0-fPivScale)*nMotPremixR + fPivScale*(-nPivSpeed); motor_left_speed =nMotMixL; motor_right_speed =nMotMixR; if (motor_right_speed> 50) { digitalWrite(MOTORB_1,HIGH); digitalWrite(MOTORB_2,LOW); } else if (motor_right_speed <-50) { digitalWrite(MOTORB_1,LOW); digitalWrite(MOTORB_2, HIGH); } else { digitalWrite(MOTORB_1, LOW); digitalWrite(MOTORB_2, LOW); } if (motor_left_speed> 50) { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, HIGH); } else if (motor_left_speed <-50) { digitalWrite(MOTORA_1,HIGH); digitalWrite(MOTORA_2,LOW); } else { digitalWrite(MOTORA_1, LOW); digitalWrite(MOTORA_2, LOW); } analogWrite(ENA, abs(motor_left_speed)); analogWrite(ENB, abs(motor_right_speed)); if (abs(motor_left_speed> 50) || abs(motor_left_speed> 50)) { Serial.println("Moving!"); } vertraging(50); } }

Schema's