Eenvoudige en slimme robotarm met Arduino

Over dit project

In deze tutorial maak ik een eenvoudige robotarm die wordt bestuurd met een masterarm. De arm onthoudt bewegingen en speelt in volgorde. Het concept is niet nieuw. Ik kreeg het idee 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 (Amazon Link)

2. Potentiometers x 5 (Amazon Link)

3. Arduino UNO. (Amazon-link)

4. Batterij. (Ik gebruik een 5v-adapter)

5. Broodplank. (Amazon-link)

6. Karton/Hout/Sunboard/acryl wat er ooit beschikbaar of gemakkelijk 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 potentiometers op ijslollystokjes gelijmd en een arm gemaakt.

Als u naar de foto's verwijst, 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)
• Verbind vervolgens de signaaldraden, d.w.z. gele of oranje draad, met de PWM-pin van arduino.
• Sluit nu de potentiometers parallel aan +5v en Gnd van arduino.
• Sluit de middelste aansluiting 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 pinnen 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:Coderen

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 als 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.

#include 
//Servo Objects
Servo Servo_0;
Servo Servo_1;
Servo Servo_2;
Servo Servo_3;
Servo Servo_4;
//Potentiometer-objecten
int Pot_0;
int Pot_1;
int Pot_2; 
int Pot_3;
int Pot_4;
//Variabele om servopositie op te slaan
int Servo_0_Pos;
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 Prev_2_Pos;
int Prev_3_Pos; 
int Prev_4_Pos;
//Variabele om huidige positiewaarden op te slaan
int Current_0_Pos; 
int Current_1_Pos; 
int Current_2_Pos; 
int Current_3_Pos;
int Current_4_Pos;
int Servo_Position; // Slaat de hoek op 
int Servo_Number; //Slaat geen servo op
int Storage [600]; //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.

void setup() 
{
 Serial.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 analoge ingangspinnen 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.

void Map_Pot()
{
 /* De servo's draaien 180 graden
 maar het is geen goed idee om het te gebruiken om het te beperken
 omdat het de servo's zoemen continu
 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 =map (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 =analogRead(A1);
 Servo_1_Pos =map(Pot_1, 0, 1023, 1, 179);
 Servo_1.write (Servo_1_Pos); 
 
 Pot_2 =analoog lezen (A2); 
 Servo_2_Pos =map(Pot_2, 0, 1023, 1, 179);
 Servo_2.write(Servo_2_Pos);
 
 Pot_3 =analogRead(A3); 
 Servo_3_Pos =map(Pot_3, 0, 1023, 1, 179);
 Servo_3.write(Servo_3_Pos);
 
 Pot_4 =analogRead(A4);
 Servo_4_Pos =map(Pot_4, 0, 1023, 1, 179);
 Servo_4.write(Servo_4_Pos);
} 

• Nu gaan we de loop-functie schrijven:

void loop() 
{
 Map_Pot(); //Functie-aanroep om potwaarden te lezen
 
 while (Serial.available()> 0) 
 {
 data =Serial.read();
 if (data =='R')
 Serial.println("Bewegen opnemen...");
 if (data =='P')
 Serial.println("Opgenomen bewegingen afspelen.. .");
 }
 if (data =='R') //Als 'R' is ingevoerd, start de opname.
 {
 //Sla de waarden op in een variabele
 Prev_0_Pos =Servo_0_Pos;
 Prev_1_Pos =Servo_1_Pos;
 Prev_2_Pos =Servo_2_Pos;
 Prev_3_Pos =Servo_3_Pos;
 Vorige_4_Pos =Servo_4_Pos (); // Kaartfunctie opgeroepen voor vergelijking 
 
 if (abs(Prev_0_Pos ==Servo_0_Pos)) // absolute waarde wordt verkregen door 
 {
 Servo_0.write(Servo_0_Pos); // Als de waarden overeenkomen, wordt de servo verplaatst 
 if (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 tabelformaat */ 
 Serial.print(Servo_0_Pos); 
 Serial.print(" \t "); 
 Serial.print(Servo_1_Pos); 
 Serial.print(" \t "); 
 Serial.print(Servo_2_Pos); 
 Serial.print(" \t "); 
 Serial.print(Servo_3_Pos); 
 Serial.print(" \t "); 
 Serial.println(Servo_4_Pos);
 Serial.print ("Index ="); 
 Serial.println(Index); 
 vertraging(50); 
 }
 als (data =='P') //IF 'P' is ingevoerd, begin met het spelen van opgenomen zetten.
 {
 for (int i =0; i  {
 Servo_Number =Storage [i] / 100; // Vindt aantal servo
 Servo_Position =Opslag [i] % 100; // Vindt positie van servo
 switch(Servo_Number) 
 {
 case 0:
 Servo_0.write(Servo_Position);
 break;
 case 1:
 Servo_1.write(Servo_Position);
 pauze;
 geval 2:
 Servo_2.write(Servo_Position);
 pauze; 
 geval 3:
 Servo_3.write(Servo_Position);
 breken;
 geval 4:
 Servo_4.write(Servo_Position);
 breken;
 }
 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 master-arm. 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.

Ik hoop dat je het project leuk vindt.

Bedankt...

#include //Servo ObjectsServo Servo_0;Servo Servo_1;Servo Servo_2;Servo Servo_3;Servo Servo_4;//Potentiometer Objectsint Pot_0;int Pot_1;int Pot_2; int Pot_3;int Pot_4;//Variabele om op te slaan Servo Positionint Servo_0_Pos;int Servo_1_Pos;int Servo_2_Pos;int Servo_3_Pos;int Servo_4_Pos;//Variabele om op te slaan Vorige positiewaardenint Prev_0_Pos; int Vorige_1_Pos; int Vorige_2_Pos;int Vorige_3_Pos; int Prev_4_Pos;//Variabele om op te slaan Huidige positiewaardenint Current_0_Pos; int Current_1_Pos; int Huidige_2_Pos; int Current_3_Pos;int Current_4_Pos;int Servo_Position; // Slaat de hoek op int Servo_Number; // Slaat geen servoint Storage [600] op; // Array om gegevens op te slaan (toenemende arraygrootte zal meer geheugen verbruiken) int Index =0; // Array-index begint vanaf 0 positiechar data =0; //variabele om gegevens van seriële invoer op te slaan.

void setup() { Serial.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 ingesteld op positie 100 bij initialisatie. 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"); }

void Map_Pot(){ /* De servo's draaien op 180 graden, maar het is geen goed idee om het te gebruiken tot limieten, omdat het de servo's continu laat zoemen, wat vervelend is, dus we beperken de servo om te bewegen tussen:1-179 * / Pot_0 =analoog lezen (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);}

void loop() { Map_Pot(); // Functie-aanroep om pot-waarden 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; Prev_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 tabelformaat */ Serial.print(Servo_0_Pos); Serieel.print(" \t "); Seriële.print(Servo_1_Pos); Serieel.print(" \t "); Seriële.afdruk (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   
 
 Schema's