cable-robot

[Swets]

Min vraag gaat over het volgende:
https://www.arjan-swets.com/hardware/mi ... robot.html

en de vraag is eigenlijk,
ehhh...

ik heb dus die 8 draadjes van uit de hoeken... ik weet hoelang die draadjes zijn...

is het nu tedoen om terug te rekenen naar hoe het object hangt?

ik heb natuurlijk 8 denkbeeldig bollen, en het object hangt tussen die 8 bollen....
(misschien een beetje vaag verhaal zo, maar ik denk als je het filmpje onder aan die pagina bekijk, dat me vraag dan wel duidelijk is...)

ik denk dat het een heel moeilijk verhaal is?

[xander_C-137]

Het is makkelijker dan het op het eerste zicht lijkt. Zie onderstaande tekening en berekeningen.

Voor de gemakkelijkheid stel ik dat x_i de x-component is van draad met nummer i.
De draden zijn als volgt genummerd:
- Draad 1 tot 4 liggen vooraan en zijn tegen de richting van de klok in genummerd, beginnend linksboven.
- Draad 5 tot 8 liggen achteraan en zijn tegen de richting van de klok in genummerd, beginnend linksboven.

Als je de laatste subsitutie zelf nog uitvoert heb je een stelsel met 8 vergelijkingen en 3 variabelen, hier kies je dan de makkelijkste 3 vergelijking uit en dan is het oplossen naar x₁, y₁ en z₁. Daaruit kun je x₅, y₃ en z₂ afleiden. De componenten van alle andere draden kun je daar dan weer uit afleiden/kopiëren.

[xander_C-137]

Ik merk nu op dat het voorwerp geen exacte balk is. Die kleine verschillen in afstand moet je dus ook nog even doorrekenen door bv te schrijven:
y₁ = y₂ + b''
met b'' = het kleine verschil op de y-component

De y-componenten van 1 en 5 blijven bv. nog steeds gelijk aan elkaar omdat ze op een zelfde plaats aanhechten.
Als ik het goed zie, worden enkel de y-componenten hierdoor beïnvloed. Die moet je dus ook vervangen in de substitutie die ik reeds doorvoerde.

[RedCat]

Het stelsel wordt wel ingewikkelder als we ook de orientatie moeten meenemen.
(zie bv. https://en.wikipedia.org/wiki/Rotation_ ... _rotations)
Hier een voorbeeld blok (met bevestigingspunten A t/m H):

wtf_cables.png (6.42 KiB) 1229 keer bekeken

De draden van het bovenvlak van het blok zitten vast aan de hoekpunten van het grondvlak van de kast,
de draden van het ondervlak van het blok aan die van het bovenvlak van de kast.

Als we het assenstelsel zodanig kiezen dat:
- de oorsprong = het hoekpunt links-onder-voor van de kast
- x-as naar rechts,
- y-as naar achter,
- z-as omhoog
en de kast een kubus veronderstellen met afmetingen 100 x 100 x 100,

en als voorbeeld kiezen:
roll hoek γ = 20°
pitch hoek β = 10°
yaw hoek α = 25°
en we leggen het middelpunt van het blok op punt [40, 50, 60]

dan zijn de coordinaten van de hoekpunten van het blok:
PA = [44.9586, 49.2970, 55.0082]
PB = [42.2122, 56.3110, 57.7028]
PC = [33.2868, 52.1491, 59.4393]
PD = [36.0332, 45.1351, 56.7447]
PE = [44.9281, 47.0185, 60.9080]
PF = [42.1817, 54.0326, 63.6026]
PG = [36.8265, 51.5354, 64.6445]
PH = [39.5729, 44.5214, 61.9499]

en zijn de draadafstanden:
DA = 86.5102
DB = 83.8881
DC = 71.0133
DD = 72.1567
DE = 94.6226
DF = 97.4744
DG = 88.7914
DH = 85.9416

Weet je zeker dat jij de andere kant op wilt,
dus vanuit de draadafstanden naar de middelpuntpositie [xm, ym, zm] en rotatiehoeken α, β en γ ?

[Swets]

Allereerst bedankt voor je reactie..... ik moet het eerst nog even een paar keer door lezen om het in te laten dalen....
Ik had ook op een ander forum de vraag gesteld, en daar kwamen ze matrixen... Ik heb in het verleden eens een verhaal geschreven op een hmi-scherm van een sigamtek plc:



Dat heb ik toe geschreven met hulp van iemand die ook 3D engines geschreven had....
Zelf heb ik alleen LTS wiskunde.... dus ik had nog nooit iets met matrix gedaan....

dit verhaal is al weer een jaar of 5 a 6 geleden, en daarna natuurlijk nooit meer iets gedaan met matrixen enzo... dus ik ben dat nu ( ook weer) aan het doorlezen....

maar ik ga weer eens even alles bekijken, en dan zal ik wel weer met nieuwe vragen komen...

[Swets]

Weet je zeker dat jij de andere kant op wilt,
dus vanuit de draadafstanden naar de middelpuntpositie [xm, ym, zm] en rotatiehoeken α, β en γ ?

nou ik weet nog niets zeker....

ik wil mijn super fel gekleurde test verhaaltje laten bewegen....



dit heb ik als volgt gedaan,

ik heb het object in de midden gehangen van het frame.... ik had in solid works goed gemeten hoe lang de draden zijn, als het object precies in de midden hangt....

dat ingevuld bij de 8 draden.... (want ja je moet ergens beginnen, en nullen is ook heel lastig..)

toen heb ik gezegd, dat het hart van het frame op 0,0,0 hangt.... en nu kan ik een opdracht geven 20mm omhoog bijvoorbeeld...

dan ga ik vanuit dat 0,0,0 punt uit rekenen, als deze 20mm omhoog gaat, waar dan de 8 hoekpunten van het object zoude moeten komen, en dan dmv de stelling van Pythagoras, reken ik alle nieuwe lengtes uit van de 8 draden....

dan krijg ik dus 8 nieuwe lengtes, dan dmv een lengteMove = abs(actualLength-Wantendlength), weet ik hoeveel een draad veranderen moet...

als de wantedLength groter is als de actuele lengte moet hij de ene kant om draaien... kleiner is de andere kant op....

dan weet ik dus hoeveel de draden moeten veranderen.... die sorteer ik op lengte.... de langste krijg 100 % van de pulsen(voor de stappenmotor) en bijvoorbeeld als de 1 tov de langste maar 25% moet veranderen , krijgt die 10/25=4

dus die 100% moet veranderen, krijgt alle pulsen... die van 25% krijgt om de 4 pulsen een puls...

(hoop dat je dit allemaal nog een beetje kan volgen....

maar op deze manier gaat het dus niet werken....
want als ik een langer move doet die over de 0,0,0 heen, gaat het niet goed....
want dan zijn er natuurlijk draden die eerst korter moeten worden, en over de midden heen weer langer....


dus eigenlijk ben ik meer opzoek naar hoe ik het beste kan maken....
zodat ik hem alle kanten op kan sturen, en het liefst ook roteren....

dus ik dacht vaker de nieuwe lengtes uit rekenen.... maar omdat ik vanuit de x,y,z midden reken van het object, moet ik eigenlijk continue weten waar het midden van het object is...

maar misschien moet ik het wel heel anders opzetten???? en ben ik helemaal verkeerd begonnen...?
en dan is dus de vraag, hoe kan ik dit het beste doen?

en het doel is dus zomaar voor de lol.... kijken of ik het werkend krijg... dus er is totaal geen haast ofzo bij..

[Swets]

ik denk dat ik het nu eens zo ga doen....

ik reken op de zelfde manier de kabellengtes uit.... alleen nu als ik wil verschuiven over bijvoorbeeld de x-as...

nu reken ik in 1 keer de totale verschuiving uit.... maar ik denk nu, dat ik dat gelijk in hele kleine stapjes deel...

Dus stel dat ik 20mm wil verschuiven over de x-as... ga ik dat doen in stapjes van 0,1 mm... dus eerst verschuif ik hem 0,1... reken al draadjes uit... dan krijg ik ook maar weinig pulzen, omdat ik heel weinig verschuif.... ik voer die pulzen uit...daarna verschuif ik het object weer 0,1mm... reken weer alles uit, voer weer de pulzen uit, totdat ik 20 mm verschoven ben...

dat ga ik eerst eens proberen...

[RedCat]

Je kan het ook oplossen zonder matrices door alleen de eindresultaten daarvan te gebruiken.
De rotaties berekend via de rotatiematrices (zie bijvoorbeeld de link die ik hierboven gaf:
https://en.wikipedia.org/wiki/Rotation_ ... _rotations)
roteren de ruimte om de oorsprong.
Daarom roteren we het object eerst in de juiste orientatie, vervolgens plaatsen (transleren) we het naar de juiste locatie.

Een ruwe schets van het programma wordt dan:

[1] definieer het object (het bewegende blok):

// blokafmetingen (zie het voorbeeldplaatje uit mijn vorige post):
bloklengte=10;
blokdiepte=8;
blokhoogte=6;
bovenruimte=2;

// blokcoordinaten met blokcentrum in de oorsprong:
BA=[bloklengte/2, -blokdiepte/2, -blokhoogte/2];
BB=[bloklengte/2, blokdiepte/2, -blokhoogte/2];
BC=[-bloklengte/2, blokdiepte/2, -blokhoogte/2];
BD=[-bloklengte/2, -blokdiepte/2, -blokhoogte/2];

BE=[bloklengte/2 - bovenruimte, -blokdiepte/2, blokhoogte/2];
BF=[bloklengte/2 - bovenruimte, blokdiepte/2, blokhoogte/2];
BG=[-bloklengte/2 + bovenruimte, blokdiepte/2, blokhoogte/2];
BH=[-bloklengte/2 + bovenruimte, -blokdiepte/2, blokhoogte/2];


[2] definieer het frame en het assenstelsel daarin (oorsprong in het midden):

// frame afmeting (hier een kubus):
frame=100;

// coordinaten hoekpunten frame:
KE=[frame/2, -frame/2, -frame/2];
KF=[frame/2, frame/2, -frame/2];
KG=[-frame/2, frame/2, -frame/2];
KH=[-frame/2, -frame/2, -frame/2];

KA=[frame/2, -frame/2, frame/2];
KB=[frame/2, frame/2, frame/2];
KC=[-frame/2, frame/2, frame/2];
KD=[-frame/2, -frame/2, frame/2];


[3] Geef de gewenste orientatie en middelpuntlocatie van het object:

// rotatie-hoeken:
gamma = 20 *Pi/180; \\ roll-hoek in radialen
beta = 10 *Pi/180; \\ pitch-hoek in radialen
alfa = 25 *Pi/180; \\ yaw-hoek in radialen

// translatie-vector (10 naar links, 0 naar voor/achter, 10 omhoog):
t = [-10, 0, 10];


[4] Bereken de kabel-aangrijpingspunten van het object na rotatie en translatie:

ca=cos(alfa);
sa=sin(alfa);
cb=cos(beta);
sb=sin(beta);
cg=cos(gamma);
sg=sin(gamma);

// P[1] = de x-coordinaat van de eindpositie, P[2] de y-coordinaat en P[3] de z-coordinaat:
PA[1] = ca*cb*BA[1] + (ca*sb*sg-sa*cg)*BA[2] + (ca*sb*cg+sa*sg)*BA[3] + t[1];
PA[2] = sa*cb*BA[1] + (sa*sb*sg+ca*cg)*BA[2] + (sa*sb*cg-ca*sg)*BA[3] + t[2];
PA[3] = -sb*BA[1] + cb*sg*BA[2] + cb*cg*BA[3] + t[3];

PB[1] = ca*cb*BB[1] + (ca*sb*sg-sa*cg)*BB[2] + (ca*sb*cg+sa*sg)*BB[3] + t[1];
PB[2] = sa*cb*BB[1] + (sa*sb*sg+ca*cg)*BB[2] + (sa*sb*cg-ca*sg)*BB[3] + t[2];
PB[3] = -sb*BB[1] + cb*sg*BB[2] + cb*cg*BB[3] + t[3];

PC[1] = ca*cb*BC[1] + (ca*sb*sg-sa*cg)*BC[2] + (ca*sb*cg+sa*sg)*BC[3] + t[1];
PC[2] = sa*cb*BC[1] + (sa*sb*sg+ca*cg)*BC[2] + (sa*sb*cg-ca*sg)*BC[3] + t[2];
PC[3] = -sb*BC[1] + cb*sg*BC[2] + cb*cg*BC[3] + t[3];

PD[1] = ca*cb*BD[1] + (ca*sb*sg-sa*cg)*BD[2] + (ca*sb*cg+sa*sg)*BD[3] + t[1];
PD[2] = sa*cb*BD[1] + (sa*sb*sg+ca*cg)*BD[2] + (sa*sb*cg-ca*sg)*BD[3] + t[2];
PD[3] = -sb*BD[1] + cb*sg*BD[2] + cb*cg*BD[3] + t[3];

PE[1] = ca*cb*BE[1] + (ca*sb*sg-sa*cg)*BE[2] + (ca*sb*cg+sa*sg)*BE[3] + t[1];
PE[2] = sa*cb*BE[1] + (sa*sb*sg+ca*cg)*BE[2] + (sa*sb*cg-ca*sg)*BE[3] + t[2];
PE[3] = -sb*BE[1] + cb*sg*BE[2] + cb*cg*BE[3] + t[3];

PF[1] = ca*cb*BF[1] + (ca*sb*sg-sa*cg)*BF[2] + (ca*sb*cg+sa*sg)*BF[3] + t[1];
PF[2] = sa*cb*BF[1] + (sa*sb*sg+ca*cg)*BF[2] + (sa*sb*cg-ca*sg)*BF[3] + t[2];
PF[3] = -sb*BF[1] + cb*sg*BF[2] + cb*cg*BF[3] + t[3];

PG[1] = ca*cb*BG[1] + (ca*sb*sg-sa*cg)*BG[2] + (ca*sb*cg+sa*sg)*BG[3] + t[1];
PG[2] = sa*cb*BG[1] + (sa*sb*sg+ca*cg)*BG[2] + (sa*sb*cg-ca*sg)*BG[3] + t[2];
PG[3] = -sb*BG[1] + cb*sg*BG[2] + cb*cg*BG[3] + t[3];

PH[1] = ca*cb*BH[1] + (ca*sb*sg-sa*cg)*BH[2] + (ca*sb*cg+sa*sg)*BH[3] + t[1];
PH[2] = sa*cb*BH[1] + (sa*sb*sg+ca*cg)*BH[2] + (sa*sb*cg-ca*sg)*BH[3] + t[2];
PH[3] = -sb*BH[1] + cb*sg*BH[2] + cb*cg*BH[3] + t[3];

[5] Bereken de draadlengtes:

// draadlengtes (via de stelling van Pythagoras):
DA = sqrt( (PA[1]-KA[1])^2 + (PA[2]-KA[2])^2 + (PA[3]-KA[3])^2 );
DB = sqrt( (PB[1]-KB[1])^2 + (PB[2]-KB[2])^2 + (PB[3]-KB[3])^2 );
DC = sqrt( (PC[1]-KC[1])^2 + (PC[2]-KC[2])^2 + (PC[3]-KC[3])^2 );
DD = sqrt( (PD[1]-KD[1])^2 + (PD[2]-KD[2])^2 + (PD[3]-KD[3])^2 );
DE = sqrt( (PE[1]-KE[1])^2 + (PE[2]-KE[2])^2 + (PE[3]-KE[3])^2 );
DF = sqrt( (PF[1]-KF[1])^2 + (PF[2]-KF[2])^2 + (PF[3]-KF[3])^2 );
DG = sqrt( (PG[1]-KG[1])^2 + (PG[2]-KG[2])^2 + (PG[3]-KG[3])^2 );
DH = sqrt( (PH[1]-KH[1])^2 + (PH[2]-KH[2])^2 + (PH[3]-KH[3])^2 );


Punten [1] en [2] zijn één keer nodig, punten [3], [4] en [5] bereken je herhaald voor elke stap in je laatste post.

[RedCat]

PS
Je orientatie en positie zijn dus een functie van tijd:

Wil je het object bijvoorbeeld een cirkel laten maken in het x-z-vlak met straal R en hoeksnelheid omega, dan wordt de translatievector T (= de gewenste positie) afhankelijk van tijd:
Tx(t) = R*cos(omega*t)
Ty(t) = 0;
Tz(t) = R*sin(omega*t)

De tijd t laat je steeds toenemen met een vaste stapgrootte delta_t,
en kijkt voor elke stap naar de verandering van draadlengtes, zoals je al schreef.

[Swets]

Ja, ik geloof dat ik het plaatje nu in me hoofd heb.....

nu kijken of ik het in de arduino kan krijgen....

heb net je hele verhaaltje uitgeprint... kan ik het nog een paar keer door lezen....
ik heb soms ff tijd nodig om het allemaal te op de goede plek in me hoofd te laten vallen....

toen ik met dat stapelpatronen verhaal bezig was, ben ik dus heel erg geholpen door iemand.... want ik had nog nooit van matrixen gehoord.... en hoewel ik er maar heel weinig van weet, vond ik het wel een heel fascinerende stof....

ik had eerst een paar linkjes gehad.... maar begreep helemaal niet hoe je dat moest toepassen en of lezen... https://nl.wikipedia.org/wiki/Matrix_(wiskunde) maar zo'n verhaal heb ik zoveel moeite mee... ik snap er eigenlijk nog niets van.... hoe ik dat nu lezen moet met al die haken enzo....... ook ben ik heel erg dyslectische... (heb daarvoor vroeger ook op een LOM school gezeten) en lezen is en blijft voor mijn lastig... ik moet me echt door zo'n verhaal heel worstelen, om eigenlijk te begrijpen wat ik nu eigenlijk lees....

dus ja ik heb gewoon wat meer tijd nodig om het te behappen....
maar ja zo heb ik wel door hobby en doorworstelen... binair en hexadecimaal reken geleerd en booleaanse algebra... en Karnaugh-diagramen enzo geleerd... dus ik zal niet helemaal achterlijk zijn... maar het gaat niet vanzelf....

[Swets]

ook wel lastig is de arduino, althans... je kan dan wel met de serial monitor een beetje debuggen.... maar je kan niet zoals in andere programmeer pakketten bijvoorbeeld een breekpunt zetten, en dat je programma dan stopt, en dat je dan ff kan kijken wat voor waarden er nu uitgerekend zijn... enzo....

ben ook blij dat ik de draadjes via magneetjes vast gemaakt heb....