hulp met ontwikkelen (inverse kinematics) in verilog

Als je bedoelt dat je op een of andere manier cos^-1 en tan^-1 functies wilt kunnen berekenen in je verilog, zou ik zeggen benader ze met een taylorreeks. Meer bepaalt dit. Uiteraard komen er nog enkele voorwaarden aan te pas, dus zou ik aanraden om wat onderzoek te doen naar taylorreeksen of reeksontwikkeling.

Ik zou ook naar dit document kunnen wijzen, welke gepresenteerd wordt als een min or meer complete uitwerking ervan. Maar of deze daadwerkelijk ook klopt weet ik niet zeker. Dit was trouwens ook het eerste resultaat toen ik een google op "acos atan verilog" uitvoerde ...

dat is een van de problemen
ik heb op school nog niet gehad over al die soorten berekeningen (vmbo-b)

Eerst dacht ik dat je problemen had met een inverse cos en tan te implementeren in verilog, maar blijkbaar zat ik daar mis. Mijn tweede opvatting van je start post is dat je eigenlijk niet echt weet hoe je verschillende posities berekent en daar hulp bij nodig hebt.

Of misschien heb je een "poot" van een hexapod maar sukkel je met het berekenen van hoe je deze moet bewegen om naar een bepaalde positie te brengen (Hint: oneindig veel oplossingen in dit geval).

Of misschien weet je wel hoe deze moet bewegen maar hebt geen idee van hoe je dit in verilog moet aanpakken?

Kortom, je vraag is zeer vaag, er zijn te veel opvattingen mogelijk. Kun je misschien meer uitleg geven over wat je echt nodig hebt? Wat bedoel je exact met "helpen met het maken van deze module"? Wat houd module in? Verilog code? Een mechanisch systeem?

ik wil graag nu inverse kinematics erin zetten om de poten makelijker te laten bewegen
maar ik weet niet hoe dat precies moet (cos tan niet in verilog)

Ik zou niet weten hoe je een echte atan/acos kunt implementeren. Ik weet wel dat het moeilijk en groot zal worden. "Normaal" zou je je al achter je oren moeten krabben als je een multiplier of -erger nog- een deler nodig hebt. Deze functies zijn nog veel "erger" in hardware.
Als het echt moet: probeer eens of je het met een ROM table kunt maken. Dus een tabel met vooraf berekende waardes erin. Ik kan me voorstellen dat de nauwkeurigheid niet zo erg groot hoeft te zijn zodat je met een tabellengte van (bv) 32 al voldoende resultaat hebt.

Op 31 december 2009 23:31:54 schreef CherryMoon:
Eerst dacht ik dat je problemen had met een inverse cos en tan te implementeren in verilog, maar blijkbaar zat ik daar mis.

[...]

Kortom, je vraag is zeer vaag, er zijn te veel opvattingen mogelijk. Kun je misschien meer uitleg geven over wat je echt nodig hebt? Wat bedoel je exact met "helpen met het maken van deze module"? Wat houd module in? Verilog code? Een mechanisch systeem?

Om even te verduidelijken: Inverse kinematics is het tegenovergestelde van forward kinematics. Forward kinematics is wanneer je bijvoorbeeld de hoek van punt A en B weet(zie plaatje) en je zo de coordinaten van punt C gaat bereken.

Bij inverse kinematics is het net andersom, je weet de coordinaten van C en gaat dan de hoeken van A en B berekenen, wat dus de servo's op je robot zijn. Voor die berekeningen heb je verschillende wiskundige functies nodig, zoals cosines, tangens, enz.

Waarschijnlijk zal het makkelijker zijn om een look-up table te maken dan een hele module in verilog te maken.
Misschien zijn er bestaande modules te vinden? Dat zou uiteraard het makkelijkst zijn...

Je zou ook nog naar cordic kunnen kijken, dit zit bij Xilinx in de ip core generator. Maar zover ik weet is er niet iets soortgelijks bij Altera. Maar misschien dat het toch toe te passen is.

edit: misschien is dit wat http://www.altera.com/literature/an/an263.pdf

edit 2: je zou ook nog de nios 2 processor kunnen gebruiken, maar dan zijn de oplossingen met lookup table en taylorreeks toch netter.

[Bericht gewijzigd door RvdW op vrijdag 1 januari 2010 13:33:32 (21%)]

als u een nios II tutorial kent hoor ik dat graag
ik heb hem zelf nog nooit gebruikt
maar ben wel aan het kijken geweest (kan het noch niet vinden)

Hoe je een nios 2 processor in een ontwerp zet staat hier http://www.altera.com/literature/tt/tt_nios2_hardware_tutorial.pdf en uitleg over het programmeren hier http://www.altera.com/literature/tt/tt_my_first_nios_sw.pdf
Er is nog veel meer over geschreven, bijvoorbeeld over hoe je sdram kan toevoegen. Dit is waarschijnlijk wel nodig aangezien de hoeveelheid geheugen op de fpga zelf niet zoveel is. Als je wilt kan je er dan ook nog linux op zetten. Maar waarschijnlijk gaat dit je doel een beetje voorbij en is die lookup table toch een stuk makkelijker.

ik heb nu via deze site dit excel rekensometje gemaakt >>> http://www.learnaboutrobots.com/inverseKinematics.htm
maar hij werkt niet zou iemand mij willen helpen
zie http://omega-thunder.nl/Hosting/omega-upload/download.php?file=942IK.x…

daarvoor is een processor ideaal. plak die nios in je systeem en laat die dat rekenwerk doen. bouw je pwm drivers voor je servos als blok hardware en je nios kan direct de kanalen schrijven.

oke
ik ben nu bezig de tutorial te lezen maar ik zag ergens dat je minimaal 2,7k logic nodig hebt
en mijn max II is maar 2,2k

Volgens mij ondersteund de Max II helemaal geen nios:
"Error: cpu_0: Device Family Max II is not supported by Altera Nios II"

Nee, in een CPLD kan je geen Nios plakken. Je hebt daar een FPGA voor nodig.

Voor zo een robot controller zou ik altijd een processor gebruiken. Het is echt té lastig om dat ik hardware te implementeren, en als je algoritme wat veranderd zit je direct met grote lastige aanpassingen. In software is dat veel gemakkelijker. Een FPGA dient ook niet voor dit soort dingen. De FPGA is dan weer wel ideaal om de servos aan te sturen (PWM controllers), welke dan weer hun commandos krijgen van een processor.

Als je je MAXII wil blijven gebruiken kan je altijd een PIC/AVR/... gebruiken om de IK uit te rekenen. De IK voor zo een poot is vrij triviaal uit te rekenen, omdat je maar een beperkt aantal DOF hebt. Ik zou wel een dikke µC nemen, zodat je leuke controllertjes kan uitproberen. Bv zou je dan gait pattern generators kunnen laten lopen en die bijsturen dmv sensor input (dat is hoe het bij insecten gaat).

De hele vraag is nu: waarom wil je persé IK doen? Wat wil je uiteindelijk bereiken met je hexapod?

nou met IK hoef ik niet heel hard te rekenen om alle gaits zelf te maken
ik wil hem gaan besturen met een nunchuck en de twee achterste knopen dienen dan om omhoog en omlaag te kunnen tijdens het lopen
en met ik is dat veel makkelijker
maar ik had dat excel bestandje gemaakt maar die werkt niet zou iemand kunnen kijken waarom niet
want dan kan ik alle waardes zelf uitrekenen en in een lookup zetten

Ok, dan ga je wel wat ingewikkeldere IK berekeningen tegemoet: je heb namelijk 3DOF per poot, en nog eens 6 poten, wat neerkomt op 18DOF... Een extratje maakt het probleem nog viezer: slechts 3 van de 6 poten gaan echt in vloed hebben op de hoogte van het punt op het achterste van de robot. Dat zorgt voor discontinuiteiten in de oplossingsruimte.

Of je de IK rechtstreeks kan uitrekenen betwijfel ik... Je zal voldoende constraints moeten opleggen aan je oplossing om er enigsinds een resultaat uit te krijgen. Maar of de oplossing analytisch uit te schrijven is weet ik niet, maar betwijfel ik ten zeerste.

Je zou dan een Genetic Algorithm kunnen gebruiken om een oplossing te zoeken, maar dan vervalt het hele nut van on the fly IK. Op voorhand de IK uitrekenen voor de gaits zou kunnen, en je kan dat doen voor verschillende hoogtes van het middenpunt van de bot, en die inderdaad in een LUT zetten (gait pattern generator dus)

[Bericht gewijzigd door stecj366 op zaterdag 9 januari 2010 16:10:17 (21%)]

de (z) ass heb ik al zie

function [0:7] zas;
input [0:4] inputt;
	case (inputt)
		0:	zas = 255;
		1:	zas = 219;
		2:	zas = 203;
		3:	zas = 191;
		4:	zas = 179;
		5:	zas = 170;
		6:	zas = 161;
		7:	zas = 152;
		8:	zas = 143;
		9:	zas = 136;
		10:	zas = 128;
		11:	zas = 119;
		12:	zas = 111;
		13:	zas = 102;
		14:	zas = 93;
		15:	zas = 84;
		16:	zas = 76;
		17:	zas = 64;
		18:	zas = 51;
		19:	zas = 36;
		20:	zas = 0;
	endcase
endfunction

zo wil ik het ook gaan doen met de x en y as

En wat is dit juist?

Het aansturen van zulk een robot is serious business... Niet echt triviaal, omdat er zoveel vrijheidsgraden zijn. Een mooi probleem, dat zeker, en een mooi project om aan te pakken, maar wel eentje waar je goed naar moet kijken. Inverse Kinematics is een slecht gesteld probleem omdat er meerdere oplossingen zijn. De oplossingen worden snel instabiel...

Als je echt goeie resultaten wil bereiken zou ik eerst een IK oplosser maken voor simpele robots (2 DOF om te beginnen in een 2D wereld), in een omgeving zoals Matlab, GNU Octave of Scilab. Daarmee leer je dan ineens met een goeie omgeving om eender wat te doen te werken, en je gaat meer inzicht krijgen in de IK problematiek. Dan zou ik de volledige IK chain van je hexapod modelleren, en hiervoor een IK solver uitproberen, en zien hoever je daarmee dan geraakt.

Duik eens in de literatuur (google scholar gebruiken, en je zal zat papers vinden over het aansturen van zo een hexapod)

ik heb eens hard zitten denken maar volgens mij begrijpt u me verkeerd
het is de bedoeling om een x en y punt van de top van de poot op te geven en dat de ik de positie van mijn twee assen berekent

body
[as 1]----------[as 2]
                  |
                  |
                  |
                [x,y] punt poot 

Ah ok Dat is al heel wat makkelijker... Toch zou ik hiervoor nog altijd een processor gebruiken, omdat het nu eenmaal gemakkelijker en flexibeler is om het uit te rekenen in software.

Zie bijvoorbeeld dit:

http://nl.wikipedia.org/wiki/Sinus_en_cosinus#Geschiedenis

Je weet de lengte van je poot, nu kun je met bovengenoemde goniometrie de componenten van de verschillende assen uitrekenen. Daarna is het simpel optellen of verder rekenen.

Voor het creeren van je sinussen, cosinussen en tangensen kun je lookup tables maken. (Hint: sinus is een verschoven cosinus, tangens is sin/cos).

Op 11 januari 2010 11:11:17 schreef stecj366:
Ah ok Dat is al heel wat makkelijker... Toch zou ik hiervoor nog altijd een processor gebruiken, omdat het nu eenmaal gemakkelijker en flexibeler is om het uit te rekenen in software.

u bedoelde toch de hele body ???
want 18 dof begreep ik niet helemaal omdat ik had gehoord dat je maar 3 dof nodig had (dus met 18 zou je zo iets krijgen )
wat ik trouwens ook wel heel mooi vind
toch ????

@: elmowww : bedankt voor de hint

Als je het zwaartepunt van de hexapod wil positioneren heb je 18 DOF (er zijn er 3 per poot, en je hebt zes poten). Als je enkel een poot wil controleren heb je slechts 3 DOF.

ik heb nog wat gevonden wat wel heel duidelijk is
zie hier : http://www.eecs.berkeley.edu/~ug/slide/pipeline/assignments/as10/ik_no…