Haptiese tekenrobot: 5 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:27

As deel van my meestersgraad by die dep. Industriële ontwerp aan die Universiteit van Eindhoven, ek het 'n haptiese tekenapparaat geskep wat gebruik kan word om 'n semi-outonome motor deur die verkeer te navigeer. Die koppelvlak word gekrabbel genoem en laat die gebruiker haptiese toestelle in 'n 2D -ruimte ervaar deur 'n veranderlike krag en ligging. Alhoewel die konsep nie hieroor handel nie, kan u hier meer lees oor Scribble:

Scribble gebruik 'n 5 bar koppelingskonfigurasie waarmee dit twee sywaartse vryheidsgrade (DoF) kan beweeg. Hierdie opstelling is redelik gewild onder prototipeerders om tekenrobotte te skep; hier is 'n paar voorbeelde:

www.projehocam.com/arduino-saati-yazan-kol-…

blogs.sap.com/2015/09/17/plot-clock-weathe…

www.heise.de/make/meldung/Sanduhr-2-0-als-Bausatz-im-heise-shop-erhaeltlich-3744205.html

Meganies is hierdie robotte maklik om te maak. Hulle benodig net basiese verbindings en het twee aandrywers wat baie vloeibare bewegings kan veroorsaak. Hierdie struktuur is ideaal vir ontwerpers wat belangstel om bewegende strukture te maak, maar ek was nie 'n meganiese ingenieur nie, maar ek het die kinematika baie moeilik gevind om na kode te vertaal. Daarom sal ek basiese Arduino -kode verskaf wat die voorwaartse en inverse kinematika bepaal, sodat u dit maklik in u toekomstige ontwerpe kan gebruik!;-)

Laai die kode hieronder af!

* EDIT: kyk na https://haply.co vir 'n soortgelyke projek *

Stap 1: Bou die struktuur

Afhangende van die doel wat u in gedagte het, moet u eers 'n 5-koppelingstruktuur ontwerp. Dink aan die afmetings, aandrywers wat u wil gebruik en hoe u die gewrigte vir gladde bewegings kan heg.

Vir my prototipe gebruik ek my kode op 'n Arduino DUE wat beheer word oor die reeks deur 'n program op my Mac wat in Open Frameworks gemaak is. Die program gebruik 'n UDP -verbinding om te kommunikeer met 'n Unity 3D -gebaseerde bestuursimulator.

Die Scribble-prototipe gebruik 5 mm-laers en is gemaak van 5 mm lasergesnyde acrilic. Die aandrywers is Frank van Valeknhoef se Haptic Engines wat voorsiening maak vir bediening, die uitlees van posisie en die uitstuur van 'n veranderlike krag. Dit het hulle ideaal gemaak vir die gewenste haptiese eienskappe van Scribble. Meer oor sy aktuators kan hier gevind word:

Stap 2: Ken u hardeware -waardes

Die voorwaartse kinematika is gebaseer op die Plot-klokweerstasie deur SAP:

Soos getoon in hul konfigurasie, word die arm uitgestrek om 'n merker vas te hou om te teken. Dit is verwyder, aangesien dit geen doel vir die prototipe gedruk het nie. Gaan die kode na as u hierdie komponent weer wil byvoeg. Die name op die foto word in my opset dieselfde gehou.

Afhangende van u hardeware, moet die algoritme u hardeware -eienskappe ken:

int leftActuator, rightActuator; // hoek om in grad aan die aktuator te skryf, verander na floats as u meer akkuraatheid verlang

int posX, posY; // die koördinate van die ligging van die wyser

Stel die resolusie van u invoerwaardes in

int posStepsX = 2000;

int posStepsY = 1000;

Afmetings van u opstelling, waardes is in mm (sien SAP -prent)

#definieer L1 73 // lengte motorarm, sien SAP -prent (links en regs is dieselfde)

#definieer L2 95 // verlengarm, sien SAP -prent (links en regs is dieselfde)

#definieer reeksX 250 // maksimum bereik in X -rigting vir die punt om te beweeg (van links na regs, 0 - maxVal)

#definieer reeks Y 165 // maksimum bereik in Y -rigting vir die punt om te beweeg (van 0 tot maksimum bereik terwyl dit in die middel bly)

#definieer oorsprong L 90 // verreken afstand van die meeste minimum X -waarde tot die posisie van die aktuator

#define originR 145 // offsetafstand van die meeste minimum X -waarde tot die posisie van die aktuator, die afstand tussen die twee motors is in hierdie geval

Stap 3: Stuur Kinematics vorentoe

Soos in die vorige stap genoem, is die voorwaartse kinematika gebaseer op SAP se algoritme.

Die leemte werk die gewenste hoekwaardes van die linker- en regteraktuator by wat vroeër gedefinieer is. Op grond van die X- en Y -waardes wat ingeprop word, sal dit die regte hoeke bereken om die wyser na hierdie posisie te bring.

void set_XY (dubbel Tx, dubbel Ty) // voer u X- en Y -waarde in {// 'n paar vals wat ons nodig het, maar nie vir lang dubbele dx, dy, c, a1, a2, Hx, Hy; // kaart inpit resolusie na omvang van u opset in die werklike wêreld int realX = kaart (Tx, 0, posStepsX, 0, rangeX); // ruil as kartering indien omgekeerd int realY = map (Ty, posStepsX, 0, 0, rangeY); // ruil as kartering indien omgekeerd // calc hoek vir linker aktuator // cartesiaanse dx/dy dx = realX - originL; // sluit offset dy = realY in; // poollengte (c) en hoek (a1) c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = terugkeerhoek (L1, L2, c); leftActuator = vloer (((M_PI - (a2 + a1)) * 4068) / 71); // finale hoek en omskakel van rad na graad // calc hoek vir regs aktuator dx = realX - originR; // sluit offset dy = realY in; c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = terugkeerhoek (L1, L2, c); rightActuator = vloer (((a1 - a2) * 4068) / 71); // finale hoek en omskakel van rad na graad}

Bykomende leemte vir hoekberekening:

double return_angle (double a, double b, double c) {// cosinus rule for angle between c and a return acos ((a * a + c * c - b * b) / (2 * a * c)); }

Stap 4: Inverse kinematika

Die inverse kinematika werk andersom. U sluit die rotasie van u aktuators in grade aan, en die leemte sal die posisie wat vroeër gedefinieer is, opdateer.

Let daarop dat u aandrywers of 'n aparte sensor benodig wat die hoek van die arm kan lees. In my geval het ek aktuators gebruik wat hul posisie gelyktydig kan lees en skryf. Eksperimenteer hiermee en oorweeg dit om 'n soort kalibrasie by te voeg, sodat u seker is dat u hoek korrek gelees word.