Përdorimi i Arduino Uno për pozicionimin XYZ të krahut robotik 6 DOF: 4 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:24

Ky projekt ka të bëjë me zbatimin e një skice të shkurtër dhe relativisht të lehtë Arduino për të siguruar pozicionimin kinematik të anasjelltë XYZ. Unë kisha ndërtuar një krah robotik 6 servo, por kur erdhi puna për të gjetur softuer për ta ekzekutuar atë, nuk kishte shumë atje përveç programeve të personalizuara që funksiononin në mburoja servo të personalizuara si SSC-32 (U) ose programe dhe aplikacione të tjera që ishin e komplikuar për tu instaluar dhe komunikuar me krahun. Pastaj gjeta "Kinematikën e kundërt të krahut robotik në Arduino" të Oleg Mazurov, ku ai zbatoi kinematikën e kundërt në një skicë të thjeshtë Arduino.

Kam bërë dy modifikime për të përshtatur kodin e tij:

1. Kam përdorur bibliotekën VarSpeedServo në vend të bibliotekës së tij të servo shield, sepse atëherë mund të kontrolloj shpejtësinë e servos dhe nuk do të më duhet të përdor mburojën servo që ai përdorte. Për këdo që merr në konsideratë drejtimin e kodit të dhënë këtu, unë rekomandoj që të përdorni këtë bibliotekë VarSpeedServo, në vend të bibliotekës servo.h, në mënyrë që të ngadalësoni lëvizjen tuaj të krahut robotik gjatë zhvillimit ose mund të zbuloni se krahu do t'ju fusë papritur fytyrën ose më keq sepse do të lëvizë me shpejtësi të plotë servo.

2. Unë përdor një sensor të thjeshtë/servo mburojë për të lidhur servos me Arduino Uno por nuk kërkon ndonjë bibliotekë të veçantë servo pasi përdor vetëm kunjat e Arduino. Kushton vetëm disa dollarë, por nuk kërkohet. Kjo siguron një lidhje të bukur të pastër të servos me Arduino. Dhe unë kurrë nuk do të kthehem në shërbimet e forta të Arduino Uno tani. Nëse përdorni këtë sensor/servo mburojë ju duhet të bëni një modifikim të vogël që do ta përshkruaj më poshtë.

Kodi funksionon shkëlqyeshëm dhe ju lejon të përdorni krahun duke përdorur një funksion të vetëm në të cilin kaloni parametrat x, y, x dhe shpejtësinë. Për shembull:

set_arm (0, 240, 100, 0, 20); // parametrat janë (x, y, z, këndi i kapjes, shpejtësia e shërbimit)

vonesë (3000); // kërkohet vonesë për të lejuar kohën e krahut për të lëvizur në këtë vendndodhje

Nuk mund të jetë më e thjeshtë. Unë do të përfshijë skicën më poshtë.

Videoja e Oleg është këtu: Kontrollimi i krahut robotik me Arduino dhe USB Mouse

Programi origjinal, përshkrimet dhe burimet e Oleg: Kinematika Inverse e Oleg për Arduino Uno

Unë nuk i kuptoj të gjitha matematikat prapa rutinës, por gjëja e bukur është se nuk keni pse të përdorni kodin. Shpresoj se do ta provoni.

Hapi 1: Ndryshimet e harduerit

1. E vetmja gjë që kërkohet është që servo juaj të kthehet në drejtimet e pritshme të cilat mund t'ju kërkojnë të ndryshoni fizikisht montimin e servos tuaj. Shkoni në këtë faqe për të parë drejtimin e pritshëm të servo për servos bazë, shpatull, bërryl dhe dore:

2. Nëse përdorni mburojën e sensorit që unë jam duke përdorur ju duhet të bëni një gjë për të: përkulni pinin që lidh 5v nga mburoja me Arduino Uno nga rruga në mënyrë që të mos lidhet me bordin Uno. Ju dëshironi të përdorni tensionin e jashtëm në mburojë për të fuqizuar vetëm servot tuaj, jo Arduino Uno ose mund të shkatërrojë Uno, e di pasi kam djegur dy pllaka Uno kur tensioni im i jashtëm ishte 6 volt dhe jo 5. Kjo ju lejon për të përdorur më shumë se 5v për të fuqizuar servos tuaj, por nëse voltazhi juaj i jashtëm është më i lartë se 5 volt, atëherë mos lidhni asnjë sensor 5 volt me mburojën ose do të skuqen.

Hapi 2: Shkarkoni Bibliotekën VarSpeedServo

Ju duhet të përdorni këtë bibliotekë që zëvendëson bibliotekën standarde servo arduino sepse ju lejon të kaloni një shpejtësi servo në deklaratën e shkrimit të servo. Biblioteka gjendet këtu:

Biblioteka VarSpeedServo

Thjesht mund të përdorni butonin zip, të shkarkoni skedarin zip dhe pastaj ta instaloni me Arduino IDE. Pasi të jetë instaluar komanda në programin tuaj do të duket si: servo.write (100, 20);

Parametri i parë është këndi dhe i dyti është shpejtësia e servo nga 0 në 255 (shpejtësia e plotë).

Hapi 3: Drejtoni këtë Skicë

Këtu është programi i konkurrimit. Ju duhet të modifikoni disa parametra për dimensionet tuaja të krahut robotik:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER gjatësi në milimetra.

2. Futni numrat tuaj të servo pin

3. Futni servo min dhe max në deklaratat e bashkëngjitura.

4. Pastaj provoni një komandë të thjeshtë set_arm () dhe më pas funksionet zero_x (), line () dhe rreth () për testim. Sigurohuni që shpejtësia e servo -s tuaj është e ulët herën e parë që i përdorni këto funksione për të parandaluar dëmtimin e krahut tuaj dhe krahut tuaj.

Paç fat.

#përfshi VarSpeedServo.h

/ * Kontrolli servo për krahun AL5D */

/ * Përmasat e krahut (mm) */

#përcakto BAZ_HGT 90 // lartësia e bazës

#përcakto HUMERUS 100 // "kocka" sup-bërryl

#define ULNA 135 // "kocka" bërryl-në dore

#define GRIPPER 200 // gripper (përfshirë mekanizmin e rrotullimit të dorës së rëndë) gjatësia"

#define ftl (x) ((x)> = 0? (gjatë) ((x) +0.5):(gjatë) ((x) -0.5)) // noton në konvertim të gjatë

/ * Servo emrat/numrat *

* Servo bazë HS-485HB */

#përcakto BAS_SERVO 4

/ * Servo Servo HS-5745-MG */

#përcakto SHL_SERVO 5

/ * Bërryl Servo HS-5745-MG */

#përcakto ELB_SERVO 6

/ * Servo dore HS-645MG */

#përcakto WRI_SERVO 7

/ * Servo rrotulluese servo HS-485HB */

#përcakto WRO_SERVO 8

/ * Gripper servo HS-422 */

#përcakto GRI_SERVO 9

/ * para-llogaritjet */

noton hum_sq = HUMERUS*HUMERUS;

noton uln_sq = ULNA*ULNA;

int servoSPeed = 10;

// ServoShield servos; // Objekti ServoShield

VarSpeedServo servo1, servo2, servo3, servo4, servo5, servo6;

int loopCounter = 0;

int impuls Gjerësia = 6.6;

int mikrosekondaToDegrees;

void setup ()

{

servo1.attach (BAS_SERVO, 544, 2400);

servo2.attach (SHL_SERVO, 544, 2400);

servo3.tash (ELB_SERVO, 544, 2400);

servo4.tash (WRI_SERVO, 544, 2400);

servo5.tash (WRO_SERVO, 544, 2400);

servo6.tash (GRI_SERVO, 544, 2400);

vonesë (5500);

//servos.start (); // Filloni mburojën servo

servo_park ();

vonesë (4000);

Serial.filloj (9600);

Serial.println ("Fillimi");

}

lak void ()

{

loopCounter += 1;

// set_arm (-300, 0, 100, 0, 10); //

// vonesa (7000);

// zero_x ();

//linjë();

// rreth ();

vonesë (4000);

nëse (loopCounter> 1) {

servo_park ();

// set_arm (0, 0, 0, 0, 10); // park

vonesa (5000);

dalje (0); } // program pauzë - shtyp rivendosjen për të vazhduar

// dalje (0);

}

/ * rutina e pozicionimit të krahut duke përdorur kinematikë të anasjelltë */

/* z është lartësia, y është distanca nga qendra bazë jashtë, x është krah për krah. y, z mund të jetë vetëm pozitiv */

// void set_arm (uint16_t x, uint16_t y, uint16_t z, uint16_t grip_angle)

void set_arm (float x, float y, float z, float grip_angle_d, int servoSpeed)

{

noton grip_angle_r = radianët (grip_angle_d); // këndi i kapjes në radianë për përdorim në llogaritjet

/ * Këndi bazë dhe distanca radiale nga koordinatat x, y */

noton bas_angle_r = atan2 (x, y);

float rdist = sqrt ((x * x) + (y * y));

/ * rdist është y koordinatë për krahun */

y = rdist;

/ * Zhvendosjet e kapjes të llogaritura bazuar në këndin e kapjes */

noton grip_off_z = (mëk (grip_angle_r)) * GRIPPER;

noton grip_off_y = (cos (grip_angle_r)) * GRIPPER;

/ * Pozicioni i kyçit të dorës */

noton dore_z = (z - grip_off_z) - BASE_HGT;

noton dore_y = y - grip_off_y;

/ * Distanca nga shpatulla në kyç (AKA sw) */

noton s_w = (dore_z * dore_z) + (dore_y * dore_y);

noton s_w_sqrt = sqrt (s_w);

/ * këndi s_w në tokë */

noton a1 = atan2 (dore_z, dore_y);

/ * këndi s_w në humerus */

noton a2 = acos (((hum_sq - uln_sq) + s_w) / (2 * HUMERUS * s_w_sqrt));

/ * këndi i shpatullave */

noton shl_angle_r = a1 + a2;

noton shl_angle_d = gradë (shl_angle_r);

/ * këndi i bërrylit */

noton elb_angle_r = acos ((hum_sq + uln_sq - s_w) / (2 * HUMERUS * ULNA));

noton elb_angle_d = gradë (elb_angle_r);

noton elb_angle_dn = - (180.0 - elb_angle_d);

/ * kënd dore */

noton wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/ * Pulset servo */

noton bas_servopulse = 1500.0 - ((gradë (baz_angulli_r)) * impuls Gjerësia);

noton shl_servopulse = 1500.0 + ((shl_angle_d - 90.0) * impuls Gjerësia);

noton elb_servopulse = 1500.0 - ((elb_angle_d - 90.0) * impuls Gjerësia);

// noton wri_servopulse = 1500 + (wri_angle_d * pulseWidth);

// noton wri_servopulse = 1500 + (wri_angle_d * pulseWidth);

float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); // përditësuar 2018/2/11 nga jimrd - ndryshova plusin në një minus - nuk jam i sigurt se si funksiononte ky kod për këdo më parë. Mund të jetë që servoja e bërrylit ishte montuar me 0 gradë përballë dhe jo lart.

/ * Set servos */

//servos.setposition(BAS_SERVO, ftl (bas_servopulse));

mikrosekondaToDegrees = harta (ftl (bas_servopulse), 544, 2400, 0, 180);

servo1.write (mikrosekondaToDegrees, servoSpeed); // përdorni këtë funksion në mënyrë që të vendosni shpejtësinë e servo //

//servos.setposition(SHL_SERVO, ftl (shl_servopulse));

mikrosekondaToDegrees = hartë (ftl (shl_servopulse), 544, 2400, 0, 180);

servo2.write (mikrosekondaToDegrees, servoSpeed);

//servos.setposition(ELB_SERVO, ftl (elb_servopulse));

mikrosekondaToDegrees = hartë (ftl (elb_servopulse), 544, 2400, 0, 180);

servo3.shkruaj (mikrosekondaToDegrees, servoSpeed);

//servos.setposition(WRI_SERVO, ftl (wri_servopulse));

mikrosekondaToDegrees = harta (ftl (wri_servopulse), 544, 2400, 0, 180);

servo4.shkruaj (mikrosekondaToDegrees, servoSpeed);

}

/ * zhvendos servot në pozicionin e parkimit */

void servo_park ()

{

//servos.setposition(BAS_SERVO, 1500);

servo1.shkruaj (90, 10);

//servos.setposition(SHL_SERVO, 2100);

servo2.shkruaj (90, 10);

//servos.setposition(ELB_SERVO, 2100);

servo3.shkruaj (90, 10);

//servos.vendosja (WRI_SERVO, 1800);

servo4.shkruaj (90, 10);

//servos.setposition(WRO_SERVO, 600);

servo5.shkruaj (90, 10);

//servos.setposition(GRI_SERVO, 900);

servo6.shkruaj (80, 10);

kthim;

}

zbrazëti zero_x ()

{

për (yaksis i dyfishtë = 250.0; yaxis <400.0; yaxis += 1) {

Serial.print ("yaxis =:"); Serial.println (yaxis);

set_arm (0, yaxis, 200.0, 0, 10);

vonesa (10);

}

për (yaksis i dyfishtë = 400.0; yaxis> 250.0; yaxis -= 1) {

set_arm (0, yaxis, 200.0, 0, 10);

vonesa (10);

}

}

/ * lëviz krahun në vijë të drejtë */

vijë e zbrazët ()

{

për (xaxis i dyfishtë = -100.0; xaxis <100.0; xaxis += 0.5) {

set_arm (xaxis, 250, 120, 0, 10);

vonesa (10);

}

për (float xaxis = 100.0; xaxis> -100.0; xaxis -= 0.5) {

set_arm (xaxis, 250, 120, 0, 10);

vonesa (10);

}

}

rrethi i zbrazët ()

{

#përcaktoni RADIUS 50.0

// këndi i notimit = 0;

float zaxis, yaxis;

për (këndi notues = 0.0; këndi <360.0; këndi += 1.0) {

yaxis = RADIUS * sin (radianët (këndi)) + 300;

zaxis = RADIUS * cos (radianët (këndi)) + 200;

set_arm (0, yaxis, zaxis, 0, 50);

vonesa (10);

}

}

Hapi 4: Fakte, çështje dhe të ngjashme…

1. Kur drejtoj nënrutinën e rrethit () roboti im lëviz më shumë në një formë eliptike sesa një rreth. Mendoj se kjo ndodh sepse servot e mi nuk janë të kalibruar. Unë testova njërën prej tyre dhe 1500 mikrosekonda nuk ishin të njëjta me 90 gradë. Do të punojë në këtë për të provuar dhe gjetur një zgjidhje. Mos besoni se ka ndonjë gjë të gabuar me algoritmin, por me cilësimet e mia. Përditësimi 2018/2/11 - sapo zbulova se kjo është për shkak të gabimit në kodin origjinal. Unë nuk shoh se si funksionoi programi i tij Kodi fiks duke përdorur këtë: float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (kodi origjinal po shtohej)

2. Ku mund të gjej më shumë informacion se si funksionon funksioni set_arm (): Uebfaqja e Oleg Mazurov shpjegon gjithçka ose siguron lidhje për më shumë informacion:

3. A ka ndonjë kontroll të gjendjes kufitare? Jo. Kur krahu im robot kalon një koordinatë të pavlefshme xyz, ai bën këtë lloj lëvizjeje qesharake si një mace që shtrihet. Unë besoj se Oleg bën disa kontrollime në programin e tij të fundit që përdor një USB për të programuar lëvizjet e krahëve. Shikoni videon e tij dhe lidheni me kodin e tij të fundit.

4. Kodi duhet pastruar dhe kodi mikrosekond mund të hiqet.