Haptische tekenrobot - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Als onderdeel van mijn master afstuderen aan de dep. Industrial Design aan de Universiteit Eindhoven heb ik een haptisch tekenapparaat gemaakt waarmee een semi-autonome auto door het verkeer kan worden genavigeerd. De interface wordt Krabbel genoemd en laat de gebruiker haptische armaturen in een 2D-ruimte ervaren door middel van een variabele kracht en locatie. Hoewel het concept niet is waar deze instructable over gaat, kun je hier meer lezen over Scribble:

Scribble maakt gebruik van een 5 bar-verbindingsconfiguratie waarmee het twee laterale vrijheidsgraden (DoF) kan verplaatsen. Deze opstelling is redelijk populair onder prototypers om tekenrobots te maken, hier zijn enkele voorbeelden:

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

Mechanisch zijn deze robots eenvoudig te maken. Ze hebben alleen basisverbindingen nodig en hebben twee actuatoren die behoorlijk wat vloeiende bewegingen kunnen maken. Deze structuur is ideaal voor ontwerpers die geïnteresseerd zijn in het maken van bewegende structuren. Hoewel ik geen werktuigbouwkundig ingenieur ben, vond ik de kinematica vrij moeilijk om naar code te vertalen. Daarom zal ik basis Arduino-code leveren die de voorwaartse en inverse kinematica berekent, zodat u deze gemakkelijk in uw toekomstige ontwerpen kunt gebruiken!;-)

Download dan onderstaande code!

* EDIT: kijk voor een soortgelijk project op https://haply.co *

Stap 1: De structuur bouwen

Afhankelijk van het doel dat u voor ogen heeft, moet u eerst een constructie met 5 scharnieren ontwerpen. Denk na over de afmetingen, actuatoren die u wilt gebruiken en hoe u de verbindingen bevestigt voor soepele bewegingen.

Voor mijn prototype voer ik mijn code uit op een Arduino DUE die serieel wordt aangestuurd door een programma op mijn Mac dat is gemaakt in Open Frameworks. Het programma gebruikt een UDP-verbinding om te communiceren met een op Unity 3D gebaseerde rijsimulator.

Het Scribble-prototype maakt gebruik van 5 mm lagers en is gemaakt van 5 mm lasergesneden acryl. De actuatoren zijn de haptische motoren van Frank van Valeknhoef die zorgen voor bediening, het uitlezen van de positie en het uitvoeren van een variabele kracht. Dit maakte ze ideaal voor de gewenste haptische eigenschappen van Scribble. Meer over zijn actuatoren vind je hier:

Stap 2: Ken uw hardwarewaarden

De voorwaartse kinematica is gebaseerd op het Plot klokweerstation van SAP:

Zoals getoond in hun configuratie wordt de arm verlengd om een marker vast te houden om te tekenen. Dit is verwijderd omdat het geen doel diende voor het krabbel-prototype. Controleer hun code als u dit onderdeel weer wilt toevoegen. De namen in de afbeelding zijn hetzelfde gehouden in mijn configuratie.

Afhankelijk van uw hardware moet het algoritme uw hardware-eigenschappen kennen:

int linksActuator, rechtsActuator; // hoek om naar de actuator te schrijven in graden, verander naar floats als je meer nauwkeurigheid wenst

int posX, posY; //de coördinaten van de locatie van de aanwijzer

Stel de resolutie van uw invoerwaarden in

int posStepsX = 2000;

int posStepsY = 1000;

Afmetingen van uw opstelling, waarden zijn in mm (zie SAP afbeelding)

#define L1 73 // lengte motorarm, zie SAP afbeelding (links en rechts zijn hetzelfde)

#define L2 95 // lengte verlengarm, zie SAP foto (links en rechts zijn hetzelfde)

#define rangeX 250 // maximaal bereik in X-richting voor het te verplaatsen punt (van links naar rechts, 0 - maxVal)

#define rangeY 165 // maximaal bereik in Y-richting voor het te verplaatsen punt (van 0 tot maximaal bereik terwijl je gecentreerd blijft)

#define originL 90 //offset afstand van de meeste minimale X-waarde tot de middenpositie van de actuator

#define originR 145 //offset afstand van de meeste minimale X-waarde tot de middenpositie van de actuator, de afstand tussen de twee motoren is in dit geval

Stap 3: Voorwaartse kinematica

Zoals vermeld in de vorige stap, is de voorwaartse kinematica gebaseerd op het algoritme van SAP.

De leegte werkt de eerder gedefinieerde gewenste hoekwaarden van de linker en rechter actuator bij. Op basis van de X- en Y-waarden die zijn aangesloten, berekent het de juiste hoeken om de aanwijzer naar deze positie te krijgen.

void set_XY (dubbele Tx, dubbele Ty) // voer je X- en Y-waarde in { // sommige vals die we nodig hebben, maar die we niet willen opslaan voor lange dubbele dx, dy, c, a1, a2, Hx, Hy; // kaart inpit resolutie naar bereik van uw configuratie in de echte wereld int realX = map (Tx, 0, posStepsX, 0, rangeX); //swap if mapping indien omgekeerd int realY = map (Ty, posStepsX, 0, 0, rangeY); //swap als mapping indien omgekeerd // calc angle voor linker actuator // cartesiaanse dx/dy dx = realX - originL; // inclusief offset dy = realY; // polaire lengte (c) en hoek (a1) c = sqrt (dx * dx + dy * dy); a1 = atan2(dy, dx); a2 = return_angle(L1, L2, c); leftActuator = vloer (((M_PI - (a2 + a1)) * 4068) / 71); // laatste hoek en converteer van rad naar deg // calc hoek voor rechter actuator dx = realX - originR; // inclusief offset dy = realY; c = sqrt(dx * dx + dy * dy); a1 = atan2(dy, dx); a2 = return_angle(L1, L2, c); rightActuator = vloer (((a1 - a2) * 4068) / 71); // laatste hoek en converteer van rad naar deg}

Extra leegte voor hoekberekening:

double return_angle (double a, double b, double c) { // cosinusregel voor hoek tussen c en a return acos ((a * a + c * c - b * b) / (2 * a * c)); }

Stap 4: Inverse kinematica

De inverse kinematica werkt andersom. U sluit de rotatie van uw actuators in graden aan en de leegte zal de eerder gedefinieerde positie bijwerken.

Houd er rekening mee dat u actuatoren of een aparte sensor nodig heeft die de hoek van de arm kan lezen. In mijn geval heb ik actuatoren gebruikt die hun positie tegelijkertijd kunnen lezen en schrijven. Voel je vrij om hiermee te experimenteren en overweeg een soort kalibratie toe te voegen, zodat je zeker weet dat je hoek correct wordt gelezen.