Použití Arduino Uno pro XYZ Umístění 6 robotických ramen DOF: 4 kroky

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:22

Tento projekt je o implementaci krátké a relativně snadné skici Arduina, která poskytuje inverzní kinematické polohování XYZ. Postavil jsem robotickou ruku se 6 servy, ale když došlo na nalezení softwaru pro jeho spuštění, nebylo toho moc, kromě vlastních programů běžících na vlastních servo štítech jako SSC-32 (U) nebo jiných programů a aplikací, které byly komplikovaná instalace a komunikace s ramenem. Poté jsem našel nejúžasnější „Inverzní kinematiku robotické paže na Arduinu“Olega Mazurova, kde implementoval inverzní kinematiku v jednoduchém skicu Arduina.

Provedl jsem dvě úpravy, abych přizpůsobil jeho kód:

1. Místo jeho vlastní knihovny servopohonů jsem použil knihovnu VarSpeedServo, protože jsem pak mohl ovládat rychlost serv a nemusel jsem používat servopohon, který používal. Pro kohokoli, kdo zvažuje spuštění zde uvedeného kódu, doporučuji použít tuto knihovnu VarSpeedServo, nikoli knihovnu servo.h, abyste mohli během vývoje zpomalit pohyb robotické paže, nebo můžete zjistit, že vás paže nečekaně strčí do obličej nebo horší, protože se bude pohybovat plnou rychlostí serva.

2. Pro připojení serva k Arduino Uno používám jednoduchý senzor/servo štít, ale nevyžaduje žádnou speciální knihovnu serv, protože používá pouze piny Arduina. Stojí to jen pár dolarů, ale není to nutné. Umožňuje pěkné čisté připojení serv k Arduinu. A už se nikdy nevrátím k hardwiring servům do Arduino Uno. Pokud používáte tento senzor/servo štít, musíte provést jednu drobnou úpravu, kterou níže nastíním.

Kód funguje skvěle a umožňuje ovládat rameno pomocí jediné funkce, ve které předáváte parametry x, y, x a speed. Například:

set_arm (0, 240, 100, 0, 20); // parametry jsou (x, y, z, úhel chapadla, rychlost serva)

zpoždění (3000); // k přesunu na toto místo je nutné zpoždění

Jednodušší už to být nemůže. Níže uvedu skicu.

Olegovo video je zde: Ovládání robotické paže pomocí Arduino a USB myši

Olegův původní program, popisy a zdroje: Olegova inverzní kinematika pro Arduino Uno

Nerozumím celé matematice za rutinou, ale je hezké, že nemusíte používat kód. Doufám, že to zkusíte.

Krok 1: Úpravy hardwaru

1. Jediná věc, která je vyžadována, je, aby se vaše servo otáčelo v očekávaných směrech, což by mohlo vyžadovat, abyste fyzicky obrátili montáž vašich serva. Přejděte na tuto stránku a podívejte se na očekávaný směr serva pro základnu, rameno, loket a zápěstí:

2. Pokud používáte senzorový štít, který používám, musíte s tím udělat jednu věc: ohněte kolík, který spojuje 5v od štítu k Arduino Uno, tak, aby se nepřipojil k desce Uno. Chcete použít externí napětí na štítu k napájení pouze vašich serv, nikoli Arduino Uno, nebo to může zničit Uno, vím, jak jsem spálil dvě desky Uno, když moje externí napětí bylo 6 voltů místo 5. To vám umožňuje použít k napájení serva vyšší než 5 V, ale pokud je vaše externí napětí vyšší než 5 voltů, nepřipojujte ke štítu žádné 5 voltové senzory, jinak budou smažené.

Krok 2: Stáhněte si knihovnu VarSpeedServo

Musíte použít tuto knihovnu, která nahrazuje standardní servo knihovnu arduino, protože vám umožňuje předat rychlost serva do příkazu pro zápis serva. Knihovna se nachází zde:

Knihovna VarSpeedServo

Můžete jednoduše použít tlačítko zip, stáhnout soubor zip a poté jej nainstalovat pomocí Arduino IDE. Po instalaci bude příkaz ve vašem programu vypadat takto: servo.write (100, 20);

Prvním parametrem je úhel a druhým je rychlost serva od 0 do 255 (plná rychlost).

Krok 3: Spusťte tuto skicu

Zde je program soutěže. U svých robotických ramen musíte upravit několik parametrů:

1. BASE_HGT, HUMERUS, ULNA, GRIPPER délky v milimetrech.

2. Zadejte čísla pinů serva

3. Zadejte minimum a maximum serva do připojených příkazů.

4. Poté vyzkoušejte pro testování jednoduchý příkaz set_arm () a poté funkce zero_x (), line () a circle (). Při prvním spuštění těchto funkcí se ujistěte, že je vaše rychlost serva nízká, aby nedošlo k poškození vaší paže a vaší vlastní paže.

Hodně štěstí.

#include VarSpeedServo.h

/ * Servo ovládání pro rameno AL5D */

/ * Rozměry ramene (mm) */

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

#define HUMERUS 100 // „kost“od ramene k lokti

#define ULNA 135 // „kost“od lokte k zápěstí

#define GRIPPER 200 // chapadlo (vč. těžkého mechanismu otáčení zápěstí) délka"

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

/ * Názvy serv/čí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ěstí HS-645MG */

#define WRI_SERVO 7

/ * Servo otočné na zápěstí HS-485HB */

#define WRO_SERVO 8

/ * Servo chapadla HS-422 */

#define GRI_SERVO 9

/ * předběž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é nastavení ()

{

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

zpoždění (5500);

//servos.start (); // Spusťte servo štít

servo_park ();

zpoždění (4000);

Serial.begin (9600);

Serial.println ("Start");

}

prázdná smyčka ()

{

loopCounter += 1;

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

// zpoždění (7000);

// nula_x ();

//čára();

//kruh();

zpoždění (4000);

if (loopCounter> 1) {

servo_park ();

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

zpoždění (5000);

exit (0); } // pozastavení programu - pokračujte stisknutím reset

// exit (0);

}

/ * rutina polohování paže využívající inverzní kinematiku */

/* z je výška, y je vzdálenost od středu základny ven, x je ze strany na stranu. y, z může být pouze kladné */

// neplatné set_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); // úhel uchopení v radiánech pro použití ve výpočtech

/ * Základní úhel a radiální vzdálenost od souřadnic x, y */

float bas_angle_r = atan2 (x, y);

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

/ * rdist is y coordinate for the arm */

y = rdist;

/ * Posunutí úchopu vypočítané na základě úhlu úchopu */

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

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

/ * Poloha zápěstí */

float wrist_z = (z - grip_off_z) - BASE_HGT;

float wrist_y = y - grip_off_y;

/ * Vzdálenost mezi ramenem 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);

/ * s_w úhel k zemi */

float a1 = atan2 (wrist_z, wrist_y);

/ * s_w úhel k pažní kosti */

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

/ * úhel ramen */

float shl_angle_r = a1 + a2;

float shl_angle_d = stupně (shl_angle_r);

/ * úhel lokte */

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

float elb_angle_d = stupně (elb_angle_r);

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

/ * úhel zápěstí */

float wri_angle_d = (grip_angle_d - elb_angle_dn) - shl_angle_d;

/ * Servo impulzy */

float bas_servopulse = 1500,0 - ((stupně (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); // aktualizováno 2018/2/11 od Jimrda - změnil jsem plus na mínus - nejsem si jistý, jak tento kód dříve někomu fungoval. Mohlo se stát, že loketní servo bylo namontováno s 0 stupni dolů, nikoli nahoru.

/ * Nastavit serva */

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

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

servo1.write (microsecondsToDegrees, servoSpeed); // pomocí této funkce můžete nastavit rychlost 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);

}

/ * přesuňte serva do parkovací 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.write (90, 10);

//servos.setposition(GRI_SERVO, 900);

servo6.write (80, 10);

vrátit se;

}

neplatné zero_x ()

{

pro (dvojitá osa = 250,0; osa <400,0; osa += 1) {

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

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

zpoždění (10);

}

pro (dvojitá osa = 400,0; osa> 250,0; osa -= 1) {

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

zpoždění (10);

}

}

/ * pohybuje paží v přímce */

prázdný řádek ()

{

pro (dvojitá osa = -100,0; osa <100,0; osa += 0,5) {

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

zpoždění (10);

}

pro (plovoucí osa = 100,0; osa> -100,0; osa -= 0,5) {

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

zpoždění (10);

}

}

prázdný kruh ()

{

#define RADIUS 50.0

// plovoucí úhel = 0;

float zaxis, yaxis;

pro (plovoucí úhel = 0,0; úhel <360,0; úhel += 1,0) {

osa = RADIUS * sin (radiány (úhel)) + 300;

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

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

zpoždění (10);

}

}

Krok 4: Fakta, problémy a podobné…

1. Když spustím podprogram circle (), můj robot se pohybuje více v eliptickém tvaru než v kruhu. Myslím, že je to proto, že moje serva nejsou kalibrována. Testoval jsem jeden z nich a 1500 mikrosekund nebylo totéž jako 90 stupňů. Bude na tom pracovat, aby se pokusil najít řešení. Nevěřte, že je na algoritmu něco špatně, ale spíše na mém nastavení. Aktualizace 2018/2/11 - právě jsme zjistili, že je to kvůli chybě v původním kódu. Nevidím, jak jeho program fungoval Opravený kód pomocí tohoto: float wri_servopulse = 1500 - (wri_angle_d * pulseWidth); (přidával se původní kód)

2. Kde najdu více informací o tom, jak funguje funkce set_arm (): Web Olega Mazurova vše vysvětluje nebo poskytuje odkazy pro více informací:

3. Existuje kontrola okrajových podmínek? Ne. Když moje ruka robota projde neplatnou souřadnicí xyz, provede tento legrační druh vyklenutí jako kočka, která se natahuje. Věřím, že Oleg provádí kontrolu svého nejnovějšího programu, který pomocí USB programuje pohyby paží. Podívejte se na jeho video a odkaz na jeho nejnovější kód.

4. Kód je třeba vyčistit a mikrosekundový kód odstranit.