Eenvoudige en slimme robotarm met Arduino !!! - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze instructable zal ik een eenvoudige robotarm maken. Dat wordt aangestuurd met een masterarm. De arm onthoudt bewegingen en speelt in volgorde. Het concept is niet nieuw Ik heb het idee gekregen van "mini robotarm -by Stoerpeak" Ik wilde dit al heel lang maken, maar toen was ik totaal noob en had geen kennis van programmeren. Nu ben ik er eindelijk een aan het bouwen, om het simpel en goedkoop te houden en het met jullie allemaal te delen.

Dus laten we beginnen….

Stap 1: Dingen die je nodig hebt: -

Hier is een lijst met dingen die je nodig hebt: -

1. Servomotoren x 5 Link voor VS: - https://amzn.to/2OxbSH7Link voor Europa: -

2. Potentiometers x 5 (ik heb 100k gebruikt.) Link voor VS: - https://amzn.to/2ROjhDMLink voor Europa: -

3. Arduino UNO. (U kunt ook Arduino Nano gebruiken) Link voor VS:- https://amzn.to/2DBbENWLink voor Europa:-

4. Broodplank. (Ik raad deze kit aan)Link voor VS:- https://amzn.to/2Dy86w4Link voor Europa:-

5. Batterij. (optioneel, ik gebruik een 5v-adapter)

6. Karton/Hout/Sun-board/acryl wat er ooit beschikbaar is of makkelijk te vinden is.

En je moet ook Arduino IDE hebben geïnstalleerd.

Stap 2: De arm maken: -

Hier heb ik ijslollystokjes gebruikt om de arm te maken. U kunt elk materieel gebruiken dat voor u beschikbaar is. En je kunt verschillende mechanische ontwerpen proberen om een nog betere arm te maken. mijn ontwerp is niet erg stabiel.

Ik heb zojuist dubbelzijdig plakband gebruikt om de servo's op de ijslollystok te plakken en ze met schroeven vast te zetten.

Voor de Master arm heb ik potmeters op ijslollystokjes gelijmd en arm gemaakt.

Verwijzend naar de foto's krijgt u een beter idee.

Ik heb alles op een canvasbord van A4-formaat gemonteerd dat als basis wordt gebruikt.

Stap 3: Verbindingen maken: -

In deze stap zullen we alle benodigde verbindingen maken, zie de afbeeldingen hierboven.

• Sluit eerst alle servo's parallel aan op de voeding (de rode draad op +ve en zwarte of bruine draad op Gnd)
• Sluit vervolgens de signaaldraden, d.w.z. gele of oranje draad, aan op de PWM-pin van arduino.
• Verbind nu de potentiometers met +5v en Gnd van arduino parallel.
• Sluit de middelste terminal aan op de analoge pin van ardunio.

Hier worden digitale pinnen 3, 5, 6, 9 & 10 gebruikt voor het aansturen van de servo's

Analoge pennen A0 tot A4 worden gebruikt voor invoer van potentiometers.

De servo die op pin 3 is aangesloten, wordt bestuurd door een potentiometer die is aangesloten op A0

Servo aangesloten op pin 5 wordt bestuurd door pot op A1, enzovoort ….

Opmerking: - Ook al worden servo's niet aangedreven door arduino, zorg ervoor dat u de Gnd van de servo's op arduino aansluit, anders werkt de arm niet.

Stap 4: Codering: -

De logica van deze code is vrij eenvoudig, de waarden van potentiometers worden opgeslagen in een array, de records worden vervolgens doorkruist met behulp van een for-lus en de servo's doen de stappen volgens de waarden. Je kunt deze tutorial bekijken die ik heb gebruikt ter referentie "Arduino Potentiometer Servo Control & Memory"

Code:- (Downloadbaar bestand hieronder bijgevoegd.)

Eerst zullen we alle benodigde variabelen globaal declareren, zodat we ze in het hele programma kunnen gebruiken. Hiervoor is geen speciale uitleg nodig

#erbij betrekken

//Servo-objecten Servo Servo_0; Servo-Servo_1; Servo Servo_2; Servo Servo_3; Servoservo_4; // Potentiometer Objecten int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; // Variabele om Servo Positie int Servo_0_Pos op te slaan; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; // Variabele om vorige positiewaarden op te slaan int Prev_0_Pos; int Vorige_1_Pos; int Vorige_2_Pos; int Vorige_3_Pos; int Vorige_4_Pos; // Variabele om huidige positiewaarden op te slaan int Current_0_Pos; int Current_1_Pos; int Huidige_2_Pos; int Huidige_3_Pos; int Huidige_4_Pos; int Servo_Positie; // Slaat de hoek op int Servo_Number; // Slaat geen servo int Storage [600] op; //Array om gegevens op te slaan (toenemende arraygrootte zal meer geheugen verbruiken) int Index = 0; // Array-index begint vanaf de 0e positie char data = 0; //variabele om gegevens van seriële invoer op te slaan.

Nu gaan we een setup-functie schrijven, waarin we pinnen en hun functies instellen. Dit is de hoofdfunctie die als eerste wordt uitgevoerd

ongeldige setup()

{ Serieel.begin (9600); // Voor seriële communicatie tussen arduino en IDE. // Servo-objecten zijn bevestigd aan PWM-pinnen. Servo_0.attach (3); Servo_1.attach(5); Servo_2.attach(6); Servo_3.attach (9); Servo_4.attach(10); //Servo's zijn bij initialisatie ingesteld op positie 100. Servo_0.write(100); Servo_1.write(100); Servo_2.write(100); Servo_3.write(100); Servo_4.write(100); Serial.println ("Druk op 'R' om op te nemen en op 'P' om af te spelen"); }

Nu moeten we de waarden van potentiometers lezen met behulp van Analog Input-pinnen en deze in kaart brengen om servo's te besturen. Hiervoor zullen we een functie definiëren en deze een naam geven Map_Pot();, je kunt het alles noemen wat je wilt, het is een door de gebruiker gedefinieerde functie

ongeldig Map_Pot()

{ /* De servo's draaien op 180 graden, maar het is geen goed idee om het tot limieten te gebruiken, omdat het de servo's continu laat zoemen, wat vervelend is, dus we beperken de servo om te bewegen tussen: 1-179 */ Pot_0 = analogRead(A0); // Lees invoer van pot en sla deze op in de variabele Pot_0. Servo_0_Pos = kaart (Pot_0, 0, 1023, 1, 179); // Kaart servo's volgens de waarde tussen 0 tot 1023 Servo_0.write (Servo_0_Pos); // Verplaats de servo naar die positie. Pot_1 = analoog lezen (A1); Servo_1_Pos = kaart (Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos); Pot_2 = analoog lezen (A2); Servo_2_Pos = kaart (Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analoog lezen (A3); Servo_3_Pos = kaart (Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos); Pot_4 = analoog lezen (A4); Servo_4_Pos = kaart (Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Nu zullen we de lusfunctie schrijven:

lege lus()

{ Kaart_Pot(); // Functie-aanroep om potwaarden te lezen while (Serial.available () > 0) { data = Serial.read (); if (data == 'R') Serial.println("Opnamebewegingen…"); if (data == 'P') Serial.println ("Opgenomen bewegingen afspelen…"); } if (data == 'R') //Als 'R' is ingevoerd, start de opname. {// Bewaar de waarden in een variabele Prev_0_Pos = Servo_0_Pos; Vorige_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Vorige_3_Pos = Servo_3_Pos; Vorige_4_Pos = Servo_4_Pos; Map_Pot(); // Kaartfunctie opgeroepen voor vergelijking if (abs(Prev_0_Pos == Servo_0_Pos)) // absolute waarde wordt verkregen door {Servo_0.write(Servo_0_Pos) te vergelijken; // Als de waarden overeenkomen, wordt de servo verplaatst als (Current_0_Pos! = Servo_0_Pos) // Als de waarden niet overeenkomen { Storage [Index] = Servo_0_Pos + 0; // Waarde wordt toegevoegd aan array Index++; // Indexwaarde verhoogd met 1 } Current_0_Pos = Servo_0_Pos; } /* Op dezelfde manier wordt de waardevergelijking gedaan voor alle servo's, +100 wordt elke toegevoegd voor invoer als een differentiële waarde. */ if (abs(Prev_1_Pos == Servo_1_Pos)) { Servo_1.write(Servo_1_Pos); if (Current_1_Pos != Servo_1_Pos) { Opslag [Index] = Servo_1_Pos + 100; Index++; } Current_1_Pos = Servo_1_Pos; } if (abs(Prev_2_Pos == Servo_2_Pos)) { Servo_2.write(Servo_2_Pos); if (Current_2_Pos! = Servo_2_Pos) { Opslag [Index] = Servo_2_Pos + 200; Index++; } Current_2_Pos = Servo_2_Pos; } if (abs(Prev_3_Pos == Servo_3_Pos)) { Servo_3.write(Servo_3_Pos); if (Current_3_Pos! = Servo_3_Pos) { Opslag [Index] = Servo_3_Pos + 300; Index++; } Current_3_Pos = Servo_3_Pos; } if (abs(Prev_4_Pos == Servo_4_Pos)) { Servo_4.write(Servo_4_Pos); if (Current_4_Pos! = Servo_4_Pos) { Opslag [Index] = Servo_4_Pos + 400; Index++; } Current_4_Pos = Servo_4_Pos; } /* Waarden worden afgedrukt op seriële monitor, '\t' is voor het weergeven van waarden in tabelvorm */ Serial.print(Servo_0_Pos); Serieel.print(" \t "); Seriële.print(Servo_1_Pos); Serieel.print(" \t "); Seriële.print(Servo_2_Pos); Serieel.print(" \t "); Seriële.print(Servo_3_Pos); Serieel.print(" \t "); Seriële.println(Servo_4_Pos); Serial.print ("Index = "); Serial.println(Index); vertraging (50); } als (data == 'P') //IF 'P' is ingevoerd, begin met het afspelen van opgenomen zetten. { for (int i = 0; i < Index; i ++) // Doorkruis de array met for loop {Servo_Number = Storage / 100; // Vindt aantal servo Servo_Position = Opslag % 100; // Vindt positie van servoschakelaar (Servo_Number) {case 0: Servo_0.write (Servo_Position); pauze; geval 1: Servo_1.write(Servo_Position); pauze; geval 2: Servo_2.write (Servo_Position); pauze; geval 3: Servo_3.write (Servo_Position); pauze; geval 4: Servo_4.write (Servo_Position); pauze; } vertraging(50); } } }

Zodra de code gereed is, upload deze nu naar het Arduino-bord

De Smart arm is klaar om te werken. De functie is nog niet zo soepel als die van Stoerpeak.

Als je de code kunt verbeteren of suggesties voor me hebt, laat het me dan weten in het commentaargedeelte.

Dat gezegd hebbende, laten we verder gaan met testen….

Stap 5: Testen: -

Nadat u de code met succes naar het bord hebt geüpload, opent u 'Serial Monitor' en kunt u deze vinden in de optie Extra. Wanneer de seriële monitor start, wordt de arduino gereset. Nu kunt u de robotarm besturen met behulp van de masterarm. Maar er wordt niets opgenomen.

Om de opname te starten, typt u 'R' in de monitor, nu kunt u de bewegingen uitvoeren die u wilt opnemen.

Nadat de zetten zijn gedaan, moet u 'P' invoeren om de geregistreerde zetten te spelen. De servo's blijven de bewegingen uitvoeren zolang het bord niet wordt gereset.