Použitie Arduino Uno na XYZ Umiestnenie 6 robotických ramien DOF: 4 kroky

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:59

Tento projekt je o implementácii krátkeho a relatívne jednoduchého náčrtu Arduino na zaistenie inverzného kinematického polohovania XYZ. Postavil som 6-servo robotické rameno, ale keď prišlo na nájdenie softvéru na jeho spustenie, nebolo toho veľa, okrem vlastných programov bežiacich na vlastných servo štítoch, ako je SSC-32 (U) alebo iných programov a aplikácií, ktoré boli komplikovaná inštalácia a komunikácia s ramenom. Potom som našiel najúspešnejšiu „Robotickú ramennú inverznú kinematiku na Arduine“Olega Mazurova, kde implementoval inverznú kinematiku v jednoduchom náčrte Arduina.

Vykonal som dve úpravy, aby som prispôsobil jeho kód:

1. Použil som knižnicu VarSpeedServo namiesto jeho vlastnej knižnice servopohonov, pretože som potom mohol ovládať rýchlosť serv a nemusel som používať servopohon, ktorý používal. Každému, kto zvažuje spustenie tu uvedeného kódu, odporúčam použiť túto knižnicu VarSpeedServo, nie knižnicu servo.h, aby ste mohli počas vývoja spomaliť pohyb robotického ramena, alebo môžete zistiť, že vás rameno nečakane strčí do tvár alebo horšie, pretože sa bude pohybovať plnou rýchlosťou serva.

2. Na pripojenie serv k Arduino Uno používam jednoduchý senzor/servo štít, ale nevyžaduje to žiadnu špeciálnu knižnicu servo, pretože používa iba kolíky Arduino. Stojí to len pár dolárov, ale nie je to potrebné. Umožňuje pekné čisté pripojenie serv k Arduinu. A už sa nikdy nevrátim k hardwiring servom k Arduino Uno. Ak používate tento senzor/servo štít, musíte vykonať jednu menšiu úpravu, ktorú načrtnem nižšie.

Kód funguje skvele a umožňuje vám ovládať rameno pomocou jedinej funkcie, v ktorej zadáte parametre x, y, x a rýchlosť. Napríklad:

set_arm (0, 240, 100, 0, 20); // parametre sú (x, y, z, uhol uchopovača, rýchlosť serva)

oneskorenie (3000); // na presun na toto miesto je potrebné zdržanie

Jednoduchšie to byť nemôže. Skicu priložím nižšie.

Olegovo video je tu: Ovládanie robotického ramena pomocou myši Arduino a USB

Pôvodný program, popisy a zdroje Olega: Olegova inverzná kinematika pre Arduino Uno

Nerozumiem všetkej matematike za rutinou, ale je pekné, že nemusíte používať kód. Dúfam, že to vyskúšate.

Krok 1: Hardvérové úpravy

1. Jediná vec, ktorá je potrebná, je, aby sa vaše servo otáčalo v očakávaných smeroch, čo by mohlo vyžadovať, aby ste fyzicky obrátili montáž svojich serv. Prejdite na túto stránku a pozrite sa na očakávaný smer serva pre základňu, rameno, lakeť a zápästie:

2. Ak používate štítový senzor, ktorý používam, musíte s ním urobiť jednu vec: ohnite kolík, ktorý spája 5v zo štítu s Arduino Uno, tak, aby sa nepripojil k doske Uno. Chcete použiť externé napätie na štíte na napájanie iba vašich serv, nie Arduino Uno, alebo to môže zničiť Uno, viem, pretože som spálil dve dosky Uno, keď moje vonkajšie napätie bolo 6 voltov namiesto 5. To vám umožní použiť na napájanie serva napätie vyššie ako 5 V, ale ak je vaše externé napätie vyššie ako 5 voltov, potom k štítu nepripájajte žiadne 5 voltové snímače, inak budú vyprážané.

Krok 2: Stiahnite si knižnicu VarSpeedServo

Musíte použiť túto knižnicu, ktorá nahrádza štandardnú servo knižnicu arduino, pretože vám umožňuje preniesť rýchlosť serva do príkazu na zápis serva. Knižnica sa nachádza tu:

Knižnica VarSpeedServo

Môžete jednoducho použiť tlačidlo zip, stiahnuť súbor zip a potom ho nainštalovať pomocou Arduino IDE. Po inštalácii bude príkaz vo vašom programe vyzerať takto: servo.write (100, 20);

Prvým parametrom je uhol a druhým je rýchlosť serva od 0 do 255 (plná rýchlosť).

Krok 3: Spustite tento náčrt

Tu je program súťaže. Pre svoje rozmery robotického ramena musíte upraviť niekoľko parametrov:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER dĺžky v milimetroch.

2. Zadajte čísla svojich pinov servo

3. Zadajte minimum a maximum serva do príloh.

4. Potom vyskúšajte na testovanie jednoduchý príkaz set_arm () a potom funkcie zero_x (), line () a circle (). Pri prvom spustení týchto funkcií sa uistite, že rýchlosť vášho serva je nízka, aby ste predišli poškodeniu ruky a vlastnej ruky.

Veľa štastia.

#include VarSpeedServo.h

/ * Ovládanie serva pre rameno AL5D */

/ * Rozmery ramena (mm) */

#define BASE_HGT 90 // výška základne

#define HUMERUS 100 // „kosť“od ramena k lakťu

#define ULNA 135 // „kosť“od lakťa po zápästie

#define GRIPPER 200 // chápadlo (vrátane ťažkého mechanizmu otáčania zápästia) dĺžka “

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

/ * Názvy serva/čísla *

* Základné servo HS-485HB */

#define BAS_SERVO 4

/ * Ramenné servo HS-5745-MG */

#define SHL_SERVO 5

/ * Loketné servo HS-5745-MG */

#define ELB_SERVO 6

/ * Servo na zápästie HS-645MG */

#define WRI_SERVO 7

/ * Servo otáčania zápästia HS-485HB */

#define WRO_SERVO 8

/ * Servo uchopovača HS-422 */

#define GRI_SERVO 9

/ * predbežné výpočty */

float hum_sq = HUMERUS*HUMERUS;

float uln_sq = ULNA*ULNA;

int servoSPeed = 10;

// ServoShield serva; // Objekt ServoShield

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

int loopCounter = 0;

int pulseWidth = 6,6;

int mikrosekundyToDegrees;

neplatné nastavenie ()

{

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

oneskorenie (5500);

//servos.start (); // Spustite servo štít

servo_park ();

oneskorenie (4000);

Serial.begin (9600);

Serial.println ("Štart");

}

prázdna slučka ()

{

loopCounter += 1;

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

// zdržanie (7000);

// nula_x ();

// riadok ();

// kruh ();

oneskorenie (4000);

if (loopCounter> 1) {

servo_park ();

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

oneskorenie (5 000);

výjazd (0); } // pozastavenie programu - pokračujte kliknutím na reset

// exit (0);

}

/ * rutina polohovania ramien využívajúca inverznú kinematiku */

/* z je výška, y je vzdialenosť od stredu základne von, x je zo strany na stranu. y, z môže byť iba kladný */

// neplatná sada_arm (uint16_t x, uint16_t y, uint16_t z, uint16_t grip_angle)

neplatné set_arm (float x, float y, float z, float grip_angle_d, int servoSpeed)

{

float grip_angle_r = radiány (grip_angle_d); // uhol uchopenia v radiánoch na použitie vo výpočtoch

/ * Základný uhol a radiálna vzdialenosť od súradníc x, y */

float bas_angle_r = atan2 (x, y);

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

/ * rdist je y súradnica pre rameno */

y = rdist;

/ * Odchýlky úchopu vypočítané na základe uhla uchopenia */

float grip_off_z = (sin (grip_angle_r)) * GRIPPER;

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

/ * Poloha zápästia */

float wrist_z = (z - grip_off_z) - BASE_HGT;

float wrist_y = y - grip_off_y;

/ * Vzdialenosť medzi ramenom a zápästím (AKA sw) */

float s_w = (wrist_z * wrist_z) + (wrist_y * wrist_y);

float s_w_sqrt = sqrt (s_w);

/ * u_w uhol k zemi */

float a1 = atan2 (zápästie_z, zápästie_y);

/ * s_w uhol k ramennej kosti */

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

/ * uhol ramien */

float shl_angle_r = a1 + a2;

float shl_angle_d = stupne (shl_angle_r);

/ * uhol lakťa */

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

float elb_angle_d = stupne (elb_angle_r);

float elb_angle_dn = - (180,0 - elb_angle_d);

/ * uhol zápästia */

float wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/ * Servo impulzy */

float bas_servopulse = 1500,0 - ((stupne (bas_angle_r)) * šírka impulzu);

float shl_servopulse = 1500,0 + ((shl_angle_d - 90,0) * pulseWidth);

float elb_servopulse = 1500,0 - ((elb_angle_d - 90,0) * pulseWidth);

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

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

float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); // aktualizované 2018/2/11 od Jimrd - zmenil som plus na mínus - nie som si istý, ako tento kód predtým niekomu fungoval. Je možné, že lakťové servo bolo namontované s 0 stupňami smerom nadol, a nie hore.

/ * Nastaviť servá */

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

microsecondsToDegrees = mapa (ftl (bas_servopulse), 544, 2400, 0, 180);

servo1.write (microsecondsToDegrees, servoSpeed); // pomocou tejto funkcie môžete nastaviť rýchlosť serva //

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

microsecondsToDegrees = mapa (ftl (shl_servopulse), 544, 2400, 0, 180);

servo2.write (microsecondsToDegrees, servoSpeed);

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

microsecondsToDegrees = mapa (ftl (elb_servopulse), 544, 2400, 0, 180);

servo3.write (microsecondsToDegrees, servoSpeed);

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

microsecondsToDegrees = mapa (ftl (wri_servopulse), 544, 2400, 0, 180);

servo4.write (microsecondsToDegrees, servoSpeed);

}

/ * posuňte serva do parkovacej polohy */

neplatné 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.pis (90, 10);

//servos.setposition(GRI_SERVO, 900);

servo6.write (80, 10);

návrat;

}

neplatné zero_x ()

{

pre (dvojitá os x = 250,0; os <400,0; os x += 1) {

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

set_arm (0, os, 200,0, 0, 10);

oneskorenie (10);

}

pre (dvojitá os x = 400,0; os x 250,0; os x -= 1) {

set_arm (0, os, 200,0, 0, 10);

oneskorenie (10);

}

}

/ * pohybuje rukou v priamke */

prázdny riadok ()

{

pre (dvojitá os x = -100,0; os x <100,0; os x +0,5) {

sada_arm (osi, 250, 120, 0, 10);

oneskorenie (10);

}

pre (os x float = 100,0; os x> -100,0; os x -= 0,5) {

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

oneskorenie (10);

}

}

prázdny kruh ()

{

#define RADIUS 50.0

// uhol plávania = 0;

flox zaxis, yaxis;

pre (plávajúci uhol = 0,0; uhol <360,0; uhol += 1,0) {

os x = RADIUS * sin (radiány (uhol)) + 300;

zaxis = RADIUS * cos (radiány (uhol)) + 200;

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

oneskorenie (10);

}

}

Krok 4: Fakty, problémy a podobne …

1. Keď spustím podprogram circle (), môj robot sa pohybuje viac v eliptickom tvare ako v kruhu. Myslím, že je to kvôli tomu, že moje servá nie sú kalibrované. Testoval som jeden z nich a 1 500 mikrosekúnd nebolo to isté ako 90 stupňov. Bude na tom pracovať, aby sa pokúsil nájsť riešenie. Neverte, že s algoritmom je niečo v poriadku, ale skôr s mojimi nastaveniami. Aktualizácia 2018/2/11 - práve sme zistili, že je to kvôli chybe v pôvodnom kóde. Nevidím, ako jeho program fungoval Opravený kód pomocou tohto: float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (pôvodný kód bol pridaný)

2. Kde nájdem viac informácií o tom, ako funkcia set_arm () funguje: Webová stránka Olega Mazurova všetko vysvetľuje alebo poskytuje odkazy na ďalšie informácie:

3. Existuje kontrola hraničných podmienok? Nie. Keď mojej ruke robota prejdú neplatné súradnice xyz, urobí tento zábavný druh oblúkového pohybu ako mačka naťahujúca sa. Verím, že Oleg robí kontrolu vo svojom najnovšom programe, ktorý používa USB na programovanie pohybov rúk. Pozrite si jeho video a odkaz na jeho najnovší kód.

4. Kód je potrebné vyčistiť a mikrosekundový kód je možné odstrániť.