Arduino Uno izmantošana XYZ pozicionēšanai 6 DOF robotu rokām: 4 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:57

Šis projekts ir par īsas un salīdzinoši vienkāršas Arduino skices ieviešanu, lai nodrošinātu XYZ apgriezto kinemātisko pozicionēšanu. Es biju uzbūvējis 6 servopārvades robotu roku, bet, kad vajadzēja atrast programmatūru, lai to palaistu, tur nebija daudz, izņemot pielāgotas programmas, kas darbojas ar pielāgotiem servo vairogiem, piemēram, SSC-32 (U), vai citas programmas un lietotnes, kas bija sarežģīti uzstādīt un sazināties ar roku. Tad es atradu Oļega Mazurova izcilāko "Robotās rokas apgrieztā kinemātika uz Arduino", kur viņš vienkāršā Arduino skicē īstenoja apgriezto kinemātiku.

Es veicu divas izmaiņas, lai pielāgotu viņa kodu:

1. Es izmantoju VarSpeedServo bibliotēku viņa pielāgotās servo vairoga bibliotēkas vietā, jo tad es varētu kontrolēt servo ātrumu un man nebūtu jāizmanto viņa izmantotais servo vairogs. Ikvienam, kurš apsver iespēju izmantot šeit sniegto kodu, iesaku izmantot šo VarSpeedServo bibliotēku, nevis servo.h bibliotēku, lai izstrādes laikā varētu palēnināt rokas robotu kustību, vai arī jūs varat atklāt, ka roka jūs negaidīti iebāzīs. seja vai sliktāk, jo tā kustēsies ar pilnu servo ātrumu.

2. Es izmantoju vienkāršu sensoru/servo vairogu, lai savienotu servos ar Arduino Uno, taču tam nav nepieciešama īpaša servo bibliotēka, jo tā izmanto tikai Arduino tapas. Tas maksā tikai dažus dolārus, bet tas nav nepieciešams. Tas nodrošina jauku tīru servo savienojumu ar Arduino. Un es nekad vairs neatgriezīšos pie Arduino Uno vadu servos. Ja izmantojat šo sensoru/servo vairogu, jums ir jāveic nelielas izmaiņas, kuras es izklāstīšu tālāk.

Kods darbojas lieliski un ļauj vadīt roku, izmantojot vienu funkciju, kurā jūs nododat x, y, x un ātruma parametrus. Piemēram:

set_arm (0, 240, 100, 0, 20); // parametri ir (x, y, z, satvērēja leņķis, servo ātrums)

kavēšanās (3000); // ir nepieciešama aizkavēšanās, lai ļautu rokas laikam pārvietoties uz šo vietu

Vienkāršāk nevarēja būt. Zemāk es iekļaušu skici.

Oļega video ir šeit: Robotiskās rokas vadīšana ar Arduino un USB peli

Oļega sākotnējā programma, apraksti un resursi: Oļega apgrieztā kinemātika Arduino Uno

Es nesaprotu visu matemātiku, kas slēpjas rutīnā, bet jauki ir tas, ka jums nav jāizmanto kods. Ceru, ka pamēģināsiet.

1. darbība. Aparatūras modifikācijas

1. Vienīgais, kas nepieciešams, ir tas, ka jūsu servo pagriežas paredzētajos virzienos, kas var prasīt, lai jūs fiziski mainītu servo stiprinājumu. Dodieties uz šo lapu, lai redzētu paredzamo servo virzienu pamatnei, pleciem, elkoņiem un plaukstas locītavām:

2. Ja izmantojat manis izmantoto sensora vairogu, jums ir jādara viena lieta: salieciet tapu, kas savieno 5v no vairoga ar Arduino Uno, lai tā netiktu savienota ar Uno plāksni. Jūs vēlaties izmantot vairoga ārējo spriegumu, lai darbinātu tikai savus servos, nevis Arduino Uno, vai arī tas var iznīcināt Uno, es zinu, ka es sadedzināju divus Uno dēļus, kad mans ārējais spriegums bija 6 volti, nevis 5. Tas ļauj jums lai izmantotu augstāku par 5 V, lai darbinātu savus servos, bet, ja jūsu ārējais spriegums ir lielāks par 5 voltiem, tad nepievienojiet 5 voltu sensorus vairogam, pretējā gadījumā tie tiks cepti.

2. darbība: lejupielādējiet VarSpeedServo bibliotēku

Jums jāizmanto šī bibliotēka, kas aizstāj standarta arduino servo bibliotēku, jo tā ļauj ievadīt servo ātrumu servo rakstīšanas paziņojumā. Bibliotēka atrodas šeit:

VarSpeedServo bibliotēka

Jūs varat vienkārši izmantot zip pogu, lejupielādēt zip failu un pēc tam instalēt to ar Arduino IDE. Pēc instalēšanas komanda jūsu programmā izskatīsies šādi: servo.write (100, 20);

Pirmais parametrs ir leņķis, bet otrais - servo ātrums no 0 līdz 255 (pilns ātrums).

3. darbība: izpildiet šo skici

Šeit ir sacensību programma. Jums ir jāmaina daži parametri jūsu robotu roku izmēriem:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER garumi milimetros.

2. Ievadiet savus servo tapu numurus

3. Ievadiet servo min un max pielikuma paziņojumos.

4. Pēc tam izmēģiniet vienkāršu komandu set_arm () un pēc tam nulles_x (), line () un apļa () funkcijas testēšanai. Pārliecinieties, ka jūsu servo ātrums ir zems, pirmo reizi palaižot šīs funkcijas, lai nesabojātu roku un roku.

Veiksmi.

#include VarSpeedServo.h

/ * Servo vadība AL5D rokai */

/ * Rokas izmēri (mm) */

#define BASE_HGT 90 // pamatnes augstums

#define HUMERUS 100 // "plecs līdz elkonim" "kauls"

#define ULNA 135 // "kauls" no elkoņa līdz plaukstai

#define GRIPPER 200 // satvērēja (ieskaitot lieljaudas plaukstas rotācijas mehānismu) garums"

#define ftl (x) ((x)> = 0? (long) ((x) +0,5):(long) ((x) -0,5)) // float to long conversion

/ * Servo nosaukumi/numuri *

* Bāzes servo HS-485HB */

#define BAS_SERVO 4

/ * Plecu servo HS-5745-MG */

#define SHL_SERVO 5

/ * Elkoņa servo HS-5745-MG */

#define ELB_SERVO 6

/ * Rokas servo HS-645MG */

#define WRI_SERVO 7

/ * Rokas pagriešanas servo HS-485HB */

#define WRO_SERVO 8

/ * Satvērēja servo HS-422 */

#define GRI_SERVO 9

/ * iepriekš aprēķini */

pludiņš hum_sq = HUMERUS*HUMERUS;

pludiņš uln_sq = ULNA*ULNA;

int servoSPeed = 10;

// ServoShield servos; // ServoShield objekts

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

int loopCounter = 0;

int pulseWidth = 6,6;

int mikrosekundesToDegrees;

anulēts iestatījums ()

{

servo1.attach (BAS_SERVO, 544, 2400);

servo2.attach (SHL_SERVO, 544, 2400);

servo3.attach (ELB_SERVO, 544, 2400);

servo4.attach (WRI_SERVO, 544, 2400);

servo5.attach (WRO_SERVO, 544, 2400);

servo6.attach (GRI_SERVO, 544, 2400);

kavēšanās (5500);

//servos.start (); // Sāciet servo vairogu

servo_park ();

kavēšanās (4000);

Sērijas sākums (9600);

Serial.println ("Sākt");

}

tukša cilpa ()

{

loopCounter += 1;

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

// kavēšanās (7000);

// nulle_x ();

// line ();

// aplis ();

kavēšanās (4000);

ja (loopCounter> 1) {

servo_park ();

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

kavēšanās (5000);

izeja (0); } // apturēt programmu - lai turpinātu, nospiediet atiestatīšanu

// izeja (0);

}

/ * roku pozicionēšanas rutīna, izmantojot apgriezto kinemātiku */

/* z ir augstums, y ir attālums no pamatnes centra uz āru, x ir no vienas puses uz otru. y, z var būt tikai pozitīvs */

// 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)

{

pludiņš grip_angle_r = radiāni (grip_angle_d); // satvēriena leņķis radiānos izmantošanai aprēķinos

/ * Bāzes leņķis un radiālais attālums no x, y koordinātām */

pludiņš bas_angle_r = atan2 (x, y);

pludiņš rdist = sqrt ((x * x) + (y * y));

/ * rdist ir rokas koordināta */

y = rdists;

/ * Satvēriena nobīdes aprēķinātas, pamatojoties uz saķeres leņķi */

pludiņš grip_off_z = (sin (grip_angle_r)) * GRIPPER;

pludiņš grip_off_y = (cos (grip_angle_r)) * GRIPPER;

/ * Plaukstas stāvoklis */

pludiņš plaukstas locītava_z = (z - grip_off_z) - BASE_HGT;

pludiņš wrist_y = y - grip_off_y;

/ * Attālums no pleca līdz plaukstas locītavai (AKA sw) */

pludiņš s_w = (plaukstas_z * plaukstas_z) + (rokas_z * plaukstas_y);

pludiņš s_w_sqrt = sqrt (s_w);

/ * s_w leņķis pret zemi */

pludiņš a1 = atan2 (plaukstas_z, plaukstas_y);

/ * s_w leņķis pret pleca kaulu */

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

/ * plecu leņķis */

pludiņš shl_angle_r = a1 + a2;

peldēt shl_angle_d = grādi (shl_angle_r);

/ * elkoņa leņķis */

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

pludiņš elb_angle_d = grādi (elb_angle_r);

pludiņš elb_angle_dn = - (180,0 - elb_angle_d);

/ * plaukstas leņķis */

pludiņš wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/ * Servo impulsi */

pludiņš bas_servopulse = 1500,0 - ((grādi (bas_angle_r)) * pulseWidth);

pludiņš shl_servopulse = 1500.0 + ((shl_angle_d - 90.0) * pulseWidth);

pludiņš elb_servopulse = 1500,0 - ((elb_angle_d - 90,0) * pulseWidth);

// pludiņš wri_servopulse = 1500 + (wri_angle_d * pulseWidth);

// pludiņš wri_servopulse = 1500 + (wri_angle_d * pulseWidth);

float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); // atjaunināja 2018/2/11 by jimrd - es mainīju plus uz mīnusu - neesmu pārliecināts, kā šis kods kādam iepriekš darbojās. Varētu būt, ka elkoņa servo tika uzstādīts ar 0 grādiem uz leju, nevis uz augšu.

/ * Iestatīt servos */

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

mikrosekundesToDegrees = karte (ftl (bas_servopulse), 544, 2400, 0, 180);

servo1.write (mikrosekundesToDegrees, servoSpeed); // izmantojiet šo funkciju, lai varētu iestatīt servo ātrumu //

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

mikrosekundesToDegrees = karte (ftl (shl_servopulse), 544, 2400, 0, 180);

servo2.write (mikrosekundesToDegrees, servoSpeed);

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

mikrosekundesToDegrees = karte (ftl (elb_servopulse), 544, 2400, 0, 180);

servo3.write (mikrosekundesToDegrees, servoSpeed);

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

mikrosekundesToDegrees = karte (ftl (wri_servopulse), 544, 2400, 0, 180);

servo4.write (mikrosekundesToDegrees, servoSpeed);

}

/ * pārvietojiet servos stāvvietā */

void servo_park ()

{

//servos.setposition(BAS_SERVO, 1500);

servo1.write (90, 10);

//servos.setposition(SHL_SERVO, 2100);

servo2.write (90, 10);

//servos.setposition(ELB_SERVO, 2100);

servo3.write (90, 10);

//servos.setposition(WRI_SERVO, 1800);

servo4.write (90, 10);

//servos.setposition(WRO_SERVO, 600);

servo5.write (90, 10);

//servos.setposition(GRI_SERVO, 900);

servo6.rakstīt (80, 10);

atgriešanās;

}

void zero_x ()

{

par (dubultā asija = 250,0; asis <400,0; asis += 1) {

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

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

kavēšanās (10);

}

par (dubultā asija = 400,0; asis> 250,0; asis -= 1) {

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

kavēšanās (10);

}

}

/ * kustina roku taisnā līnijā */

tukša līnija ()

{

par (dubultā xaxis = -100,0; xaxis <100,0; xaxis += 0,5) {

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

kavēšanās (10);

}

par (pludiņš xaxis = 100.0; xaxis> -100.0; xaxis -= 0.5) {

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

kavēšanās (10);

}

}

tukšs aplis ()

{

#define RADIUS 50.0

// pludiņa leņķis = 0;

pludiņš zaxis, yaxis;

par (pludiņa leņķis = 0,0; leņķis <360,0; leņķis += 1,0) {

yaxis = RADIUS * sin (radiāni (leņķis)) + 300;

zaxis = RADIUS * cos (radiāni (leņķis)) + 200;

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

kavēšanās (10);

}

}

4. solis: fakti, problēmas un tamlīdzīgi…

1. Kad es izpildu apļa () apakšprogrammu, mans robots vairāk pārvietojas elipses formā nekā aplis. Es domāju, ka tas ir tāpēc, ka mani servo nav kalibrēti. Es pārbaudīju vienu no tiem, un 1500 mikrosekundes nebija tas pats, kas 90 grādi. Strādās pie tā, lai mēģinātu atrast risinājumu. Neticiet, ka ar algoritmu ir kaut kas nepareizs, bet drīzāk ar maniem iestatījumiem. Atjauninājums 2018/2/11 - tikko atklāju, ka tas ir saistīts ar kļūdu sākotnējā kodā. Es neredzu, kā viņa programma strādāja Fiksēts kods, izmantojot šo: float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (sākotnējais kods tika pievienots)

2. Kur es varu atrast vairāk informācijas par to, kā darbojas funkcija set_arm (): Oļega Mazurova vietne visu izskaidro vai sniedz saites, lai iegūtu vairāk informācijas:

3. Vai ir kāda robežnosacījumu pārbaude? Nē. Kad manai robota rokai tiek nodota nederīga xyz koordināta, tā veic šo jocīgo locīšanas kustību kā kaķis stiepjas. Es uzskatu, ka Oļegs veic pārbaudi savā jaunākajā programmā, kas izmanto USB, lai ieprogrammētu roku kustības. Skatiet viņa videoklipu un saiti uz viņa jaunāko kodu.

4. Kods ir jātīra un mikrosekundes kods var tikt noņemts.