Az Arduino Uno használata 6 DOF robotkar XYZ pozicionálásához: 4 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:42

Ez a projekt egy rövid és viszonylag egyszerű Arduino vázlat megvalósításáról szól, hogy XYZ inverz kinematikai pozícionálást biztosítson. Építettem egy 6 szervo robotkarot, de amikor szoftvert kellett találni a futtatásához, nem sok minden volt ott, kivéve az egyedi programokat, amelyek egyedi szervópajzsokon futnak, mint például az SSC-32 (U) vagy más programok és alkalmazások. bonyolult telepíteni és kommunikálni a karral. Aztán megtaláltam Oleg Mazurov legkiválóbb "Robotkar Inverse Kinematics on Arduino" című művét, ahol egy egyszerű Arduino vázlatban valósította meg az inverz kinematikát.

Két módosítást hajtottam végre a kódjának adaptálásához:

1. A VarSpeedServo könyvtárat használtam az egyéni szervo pajzskönyvtára helyett, mert akkor tudtam szabályozni a szervók sebességét, és nem kellett használnom az általa használt szervópajzsot. Mindenkinek, aki fontolóra veszi az itt megadott kód futtatását, javaslom, hogy használja ezt a VarSpeedServo könyvtárat, nem pedig a servo.h könyvtárat, hogy lelassítsa a robotkar mozgását a fejlesztés során, vagy előfordulhat, hogy a kar váratlanul belepiszkál. az arc, vagy ami még rosszabb, mert teljes szervósebességgel fog mozogni.

2. Egy egyszerű érzékelőt/szervópajzsot használok a szervók csatlakoztatásához az Arduino Uno -hoz, de nem igényel speciális szervokönyvtárat, mivel csak az Arduino csapjait használja. Csak néhány dollárba kerül, de nem kötelező. Szép tiszta kapcsolatot biztosít a szervók és az Arduino között. És soha többé nem térek vissza az Arduino Uno -hoz tartozó vezetékes szervókhoz. Ha ezt az érzékelőt/szervópajzsot használja, el kell végeznie egy kisebb módosítást, amelyet az alábbiakban felvázolok.

A kód nagyszerűen működik, és lehetővé teszi a kar működtetését egyetlen funkció használatával, amelyben megadja az x, y, x és a sebesség paramétereket. Például:

szett_kar (0, 240, 100, 0, 20); // paraméterek (x, y, z, fogószög, szervo sebesség)

késleltetés (3000); // késleltetés szükséges ahhoz, hogy az élesítési idő erre a helyre költözzön

Ennél egyszerűbb nem is lehetne. A vázlatot alább közlöm.

Oleg videója itt található: Robotkar vezérlése Arduino és USB egér segítségével

Oleg eredeti programja, leírásai és forrásai: Oleg fordított kinematikája az Arduino Uno számára

Nem értem az összes matematikát a rutin mögött, de az a szép, hogy nem kell használni a kódot. Remélem kipróbálod.

1. lépés: Hardvermódosítások

1. Az egyetlen dolog, amire szükség van, hogy a szervó a várt irányba forduljon, ami megkövetelheti, hogy fizikailag megfordítsa a szervók felszerelését. Ezen az oldalon megtekintheti az alap-, váll-, könyök- és csukló szervók várható szervo irányát:

2. Ha az általam használt érzékelőpajzsot használja, akkor egy dolgot kell tennie: hajlítsa el az 5V -ot az árnyékolástól az Arduino Uno -hoz összekötő csapot, hogy ne csatlakozzon az Uno táblához. A pajzs külső feszültségét csak a szervókra szeretné használni, az Arduino Uno -t nem, különben elpusztíthatja az Unót, tudom, hogy felégettem két Uno -táblát, amikor a külső feszültségem 6 volt volt, nem pedig 5. ha 5 V -nál nagyobb feszültséget használ a szervók tápellátásához, de ha a külső feszültsége nagyobb, mint 5 volt, akkor ne csatlakoztasson 5 voltos érzékelőket az árnyékoláshoz, különben megsül.

2. lépés: Töltse le a VarSpeedServo könyvtárat

Ezt a könyvtárat kell használnia, amely helyettesíti a szabványos arduino szervokönyvtárat, mert lehetővé teszi egy szervo sebesség átvitelét a szervo írási utasításba. A könyvtár itt található:

VarSpeedServo könyvtár

Csak használja a zip gombot, töltse le a zip fájlt, majd telepítse az Arduino IDE -vel. A telepítés után a parancs a programban így fog kinézni: servo.write (100, 20);

Az első paraméter a szög, a második pedig a szervó sebessége 0 -tól 255 -ig (teljes sebesség).

3. lépés: Futtassa ezt a vázlatot

Íme a versenyprogram. A robotkar méreteihez néhány paramétert módosítania kell:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER hossza milliméterben.

2. Írja be a szervo pin számokat

3. Adja meg a szervo min és max értékét a melléklet utasításokban.

4. Ezután próbáljon ki egy egyszerű set_arm () parancsot, majd a zero_x (), line () és circle () függvényeket a teszteléshez. Győződjön meg arról, hogy a szervo sebessége alacsony, amikor először futtatja ezeket a funkciókat, nehogy megsérüljön a karja és a saját karja.

Sok szerencsét.

#include VarSpeedServo.h

/ * Szervo vezérlés az AL5D karhoz */

/ * Kar méretei (mm) */

#define BASE_HGT 90 // alapmagasság

#define HUMERUS 100 // váll-könyök "csont"

#define ULNA 135 // könyök-csukló "csont"

#define GRIPPER 200 // fogantyú (beleértve a nagy teherbírású csuklóforgató mechanizmust) hossza"

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

/ * Szervónevek/számok *

* Alapszervó HS-485HB */

#define BAS_SERVO 4

/ * Vállszervó HS-5745-MG */

#define SHL_SERVO 5

/ * Könyök szervó HS-5745-MG */

#define ELB_SERVO 6

/ * Csukló szervó HS-645MG */

#define WRI_SERVO 7

/ * Csukló forgatható szervó HS-485HB */

#define WRO_SERVO 8

/ * Fogószervó HS-422 */

#define GRI_SERVO 9

/ * előzetes számítások */

float hum_sq = HUMERUS*HUMERUS;

float uln_sq = ULNA*ULNA;

int servoSPeed = 10;

// ServoShield szervók; // ServoShield objektum

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

int loopCounter = 0;

int pulseWidth = 6,6;

int mikroszekundumokToDegrees;

üres beállítás ()

{

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

késleltetés (5500);

//servos.start (); // Indítsa el a szervópajzsot

servo_park ();

késleltetés (4000);

Sorozat.kezdet (9600);

Serial.println ("Start");

}

üres hurok ()

{

loopCounter += 1;

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

// delay (7000);

// nulla_x ();

//vonal();

//kör();

késleltetés (4000);

if (loopCounter> 1) {

servo_park ();

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

késleltetés (5000);

kilépés (0); } // program szüneteltetése - a folytatáshoz nyomja meg a reset gombot

// exit (0);

}

/ * kar pozicionálási rutin fordított kinematikát alkalmazva */

/* z magasság, y az alap középpontjának távolsága, x oldalról oldalra. y, z csak pozitív lehet */

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

{

float grip_angle_r = radiánok (grip_angle_d); // fogási szög radiánban a számításokhoz

/ * Alapszög és radiális távolság x, y koordinátáktól */

float bas_angle_r = atan2 (x, y);

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

/ * rdist a kar y koordinátája */

y = rdist;

/ * Markolateltolások a fogási szög alapján számítva */

float grip_off_z = (sin (grip_angle_r)) * FOGÓ;

float grip_off_y = (cos (grip_angle_r)) * FOGÓ;

/ * Csuklópozíció */

float wrist_z = (z - grip_off_z) - BASE_HGT;

float wrist_y = y - grip_off_y;

/ * Váll -csukló távolság (AKA sw) */

float s_w = (csukló_z * csukló_z) + (csukló_y * csukló_y);

float s_w_sqrt = sqrt (s_w);

/ * s_w szög a talajhoz */

float a1 = atan2 (csukló_z, csukló_y);

/ * s_w szög a humerushoz */

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

/ * vállszög */

float shl_angle_r = a1 + a2;

float shl_angle_d = fok (shl_angle_r);

/ * könyök szög */

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

float elb_angle_d = fok (elb_angle_r);

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

/ * csuklószög */

float wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/ * Szervo impulzusok */

float bas_servopulse = 1500,0 - ((fok (bas_angle_r)) * pulseWidth);

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); // jimrd frissítette 2018/2/11 - a pluszt mínuszra változtattam - nem tudom, hogyan működött ez a kód korábban senkinek. Lehetséges, hogy a könyök szervót 0 fokkal lefelé, és nem felfelé szerelték fel.

/ * Szervok beállítása */

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

mikroszekundumokToDegrees = térkép (ftl (bas_servopulse), 544, 2400, 0, 180);

servo1.write (mikroszekundumokToDegrees, servoSpeed); // ezzel a funkcióval állíthatja be a szervósebességet //

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

mikroszekundumokToDegrees = térkép (ftl (shl_servopulse), 544, 2400, 0, 180);

servo2.write (mikroszekundumokToDegrees, servoSpeed);

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

mikroszekundumokToDegrees = térkép (ftl (elb_servopulse), 544, 2400, 0, 180);

servo3.write (mikroszekundumokToDegrees, servoSpeed);

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

mikroszekundumokToDegrees = térkép (ftl (wri_servopulse), 544, 2400, 0, 180);

servo4.write (mikroszekundumokToDegrees, servoSpeed);

}

/ * állítsa a szervókat parkolási helyzetbe */

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.write (80, 10);

Visszatérés;

}

void zero_x ()

{

for (dupla tengely = 250,0; yaxis <400,0; yaxis += 1) {

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

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

késleltetés (10);

}

for (dupla tengely = 400,0; yaxis> 250,0; yaxis -= 1) {

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

késleltetés (10);

}

}

/ * a karját egyenes vonalban mozgatja */

üres vonal ()

{

for (dupla xaxis = -100,0; xaxis <100,0; xaxis += 0,5) {

készlet_kar (xaxis, 250, 120, 0, 10);

késleltetés (10);

}

for (float xaxis = 100,0; xaxis> -100,0; xaxis -= 0,5) {

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

késleltetés (10);

}

}

üres kör ()

{

#define RADIUS 50.0

// lebegési szög = 0;

float zaxis, yaxis;

for (lebegési szög = 0,0; szög <360,0; szög += 1,0) {

yaxis = RADIUS * sin (radián (szög)) + 300;

zaxis = RADIUS * cos (radián (szög)) + 200;

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

késleltetés (10);

}

}

4. lépés: Tények, problémák és hasonlók…

1. Amikor futtatom a kör () alprogramot, a robotom inkább ellipszis alakban mozog, mint egy kör. Azt hiszem, ez azért van, mert a szervóim nincsenek kalibrálva. Az egyiket teszteltem, és 1500 mikroszekundum nem volt ugyanaz, mint a 90 fok. Ezen fog dolgozni, hogy megoldást találjon. Ne hidd el, hogy az algoritmussal van valami baj, inkább a beállításaimmal. Frissítés 2018/2/11 - most fedeztem fel, hogy ennek oka az eredeti kód hibája. Nem látom, hogyan működött a programja Rögzített kód ezzel: float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (az eredeti kód hozzá volt adva)

2. Hol találok további információt a set_arm () függvény működéséről: Oleg Mazurov webhelye mindent elmagyaráz, vagy linkeket tartalmaz további információkért:

3. Van -e határfeltétel -ellenőrzés? Nem. Amikor a robotkaromat érvénytelen xyz -koordinátán adják át, akkor ez a vicces fajta ívelő mozdulat olyan, mint egy macska nyújtása. Azt hiszem, Oleg némi ellenőrzést végez a legújabb programjában, amely USB -n keresztül programozza a karmozgásokat. Nézze meg videóját és linkelje a legújabb kódját.

4. A kódot meg kell tisztítani, és a mikroszekundumos kódot meg lehet szüntetni.