Haptic Drawing Robot: 5 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:46

Som en del av min magisterexamen på avdelningen. Industrial Design vid Eindhoven University, skapade jag en haptisk ritanordning som kan användas för att navigera en semi-autonom bil genom trafik. Gränssnittet kallas scribble och låter användaren uppleva haptiska fixturer i ett 2D -utrymme genom en variabel kraft och plats. Även om konceptet inte är vad det här instruerbara handlar om, kan du läsa mer om Scribble här:

Scribble använder en 5 bar kopplings konfiguration som gör att den kan flytta två sidofria frihetsgrader (DoF). Denna installation är ganska populär bland prototyper för att skapa ritrobotar, här är några exempel:

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

Mekaniskt är dessa robotar lätta att göra. De behöver bara grundfogar och har två ställdon som kan skapa en hel del flytande rörelser. Denna struktur är idealisk för formgivare som är intresserade av att göra rörlig struktur Men jag var ingenjörstekniker men jag tyckte att kinematiken var ganska svår att översätta till kod. Därför kommer jag att tillhandahålla grundläggande Arduino -kod som räknar ut framåt och invers kinematik så att du enkelt kan använda detta i dina framtida mönster!;-)

Ladda ner koden nedan!

* EDIT: för ett liknande projekt, titta på https://haply.co *

Steg 1: Bygga strukturen

Beroende på vilket syfte du har i åtanke bör du först designa en 5-kopplingsstruktur. Tänk på de mått, ställdon du vill använda och hur du fäster lederna för smidiga rörelser.

För min prototyp kör jag min kod på en Arduino DUE som styrs över serien av ett program på min Mac som gjordes i Open Frameworks. Programmet använder en UDP -anslutning för att kommunicera med en Unity 3D -baserad körsimulator.

Scribble-prototypen använder 5 mm-lager och är tillverkad av 5 mm laserskurna acrilic. Manöverdonet är Frank van Valeknhoefs Haptic Engines som möjliggör aktivering, läsning av position och utmatning av en variabel kraft. Detta gjorde dem idealiska för Scribbles önskade haptiska egenskaper. Mer om hans ställdon finns här:

Steg 2: Känn dina hårdvaruvärden

Kinematiken framåt är baserad på Plot-väderstationen från SAP:

Som visas i deras konfiguration förlängs för armen att hålla en markör att rita. Detta har tagits bort eftersom det inte tjänade något syfte för klotterprototypen. Kontrollera deras kod om du vill lägga till den här komponenten igen. Namnen på bilden hålls desamma i min konfiguration.

Beroende på din hårdvara behöver algoritmen känna till dina maskinvaruegenskaper:

int leftActuator, rightActuator; // vinkel för att skriva till ställdonet i grader, byt till floats om du önskar mer noggrannhet

int posX, posY; // koordinaterna för pekarens plats

Ställ in upplösningen för dina ingångsvärden

int posStepsX = 2000;

int posStepsY = 1000;

Mått på din installation, värdena är i mm (se SAP -bild)

#define L1 73 // längd motorarm, se SAP -bild (vänster och höger är desamma)

#define L2 95 // längdförlängningsarm, se SAP -bild (vänster och höger är desamma)

#define rangeX 250 // maximalt område i X -riktning för punkten att flytta (från vänster till höger, 0 - maxVal)

#define rangeY 165 // maximalt område i Y -riktning för punkten att röra sig (från 0 till maximal räckvidd medan du håller dig centrerad)

#define originL 90 // offset distance from most minimum X value to actuator center position

#define originR 145 // offset distance from most minimim X value to actuator center position, the distance between the two motors is in this case

Steg 3: Vidarebefordra kinematik

Som nämnts i föregående steg är framåt kinematiken baserad på SAP: s algoritm.

Tomrummet uppdaterar vänster och höger ställdons önskade vinkelvärden som definierats tidigare. Baserat på X- och Y -värdena som är anslutna kommer den att beräkna de rätta vinklarna för att få pekaren till denna position.

void set_XY (dubbel Tx, dubbel Ty) // mata in ditt X- och Y -värde {// några vals vi behöver men vill inte spara för långa dubbel dx, dy, c, a1, a2, Hx, Hy; // karta inpit upplösning till intervallet för din konfiguration i den verkliga världen int realX = map (Tx, 0, posStepsX, 0, rangeX); // swap if mapping if inversed int realY = map (Ty, posStepsX, 0, 0, rangeY); // byta om mappning om inverterad // calc vinkel för vänster ställdon // cartesian dx/dy dx = realX - originL; // inkludera offset dy = realY; // polar längd (c) och vinkel (a1) c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = retur_vinkel (L1, L2, c); leftActuator = golv (((M_PI - (a2 + a1)) * 4068) / 71); // slutvinkel och konvertera från rad till grader // kalkvinkel för höger ställdon dx = realX - originR; // inkludera offset dy = realY; c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = retur_vinkel (L1, L2, c); rightActuator = golv (((a1 - a2) * 4068) / 71); // slutvinkel och konvertera från rad till grader}

Ytterligare tomrum för vinkelberäkning:

dubbel retur_vinkel (dubbel a, dubbel b, dubbel c) {// cosinusregel för vinkel mellan c och retur acos ((a * a + c * c - b * b) / (2 * a * c)); }

Steg 4: Omvänd kinematik

Den inversa kinematiken fungerar tvärtom. Du ansluter rotationen av dina ställdon i grader och tomrummet uppdaterar positionen som definierats tidigare.

Observera att du behöver ställdon eller en separat sensor som kan avläsa armens vinkel. I mitt fall använde jag ställdon som både kan läsa och skriva sin position samtidigt. Experimentera gärna med detta och överväg att lägga till någon slags kalibrering så att du är säker på att din vinkel läses korrekt.