[Alg] Wijzers van een klok

[Jurgle]

Een keertje een algemeen topic van mij. Niet een heel specifiek probleem, maar een doel waar meerdere oplossingen voor zijn. Ik post het hier omdat jullie het denk ik ook wel leuk vinden om over na te denken.

Het gaat om het maken van een klok. Nu is dit niet zo'n heel groot probleem: in pseudocode, wat een secondewijzer laat lopen:

code:

setAchtergrond(wit); x = 0; y = 0;
while(true)
{
   t = (getSeconden() / 60) * 2 * pi;
   drawLine(0,0,x,y,wit);
   x = sin(t); y = cos(t);
   drawLine(0,0, x, y, zwart);
}

En klaar is de programmeur, maar de grafisch ontwerper wil toch wat meer. Nu is het laten zien van een wijzer ipv een lijntje en een mooie wijzerplaat als achtergrond ook niet heel moeilijk.

Wat wel lastig is, is het effect nabootsen van een klok waarbij de wijzer een impuls krijgt naar de volgende stand. Dus een grote wijzer die bijvoorbeeld op 12 staat, moet op 1 / 5 tussen de 12 en de 1 gaan staan. Je moet denken aan een stationsklok, daarvan springen de wijzers (of sprongen, met die hele nieuwe gaat het allemaal weer veel te modern) steeds naar het volgende streepje, waarna ze even schommelen om dat streepje, ze staan niet in een keer stil. Elke keer is het dus een soort van metronoom, maar dan eentje die alleen bij de eerste beweging aangedreven wordt, en dus stil komt te staan.

Mogelijke aanpak:
Je pakt niet aan zoals in bovenstaand voorbeeld, maar je maakt van de wijzers objecten, die je een impuls geeft op elke tijdseenheid dat zij in beweging moeten komen, je laat dit impuls doorlopen totdat de wijzer de beoogde positie heeft bereikt en je laat de wijzer zelf, mbv wat natuurkunde, om de positie 'dansen'. Mooi bij deze manier is dat je evt ook nog de zwaartekracht mee kan nemen en allerlei parameters kan zetten, zoals gewicht van de wijzer, kracht van de impuls, gewichtverdeling van de wijzer, etc...

Hoe zouden jullie dit aanpakken? Is er een makkelijkere aanpak? Heeft iemand dit al eens succesvol gemaakt?

[Hydra]

Edit:

Ik snap eigenlijk sowieso niet wat 't probleem is, als je gewoon de seconden tijd opvraagt neemt 'ie sowieso sprongen in plaats van analoog te bewegen.

[ Voor 79% gewijzigd door Hydra op 22-12-2005 14:50 ]

[Verwijderd]

Overigens is pi ook beschikbaar in Math, maar dat terzijde.

Ik zou het als volgt doen: Zorg dat je class die de klok tekent in een thread loopt. En laat gewoon continu je klok opnieuw tekenen (misschien met een kleine suspend er tussen). Je wijzers laat je inderdaad objecten zijn die zichzelf kunnen tekenen. Dit zijn observers en 'hangen' dus aan de tijd. Als de tijd wijzigt start je in de wijzer class een thread die enkel de waardes van de coordinaten om zichzelf te tekenen te wijzigd (dus hier zit al je fancy schudden etc).

[Verwijderd]

Ik denk dat je dan meer aan een slinger moet gaan denken (wat zo'n mooie oude metronoom ook gewoon is ). Ik ga er tenminste vanuit dat je een soort slingereffect wilt voor de secondewijzer. In principe is de beweging van de slinger periodiek, kun je dus vrij mooi nabootsen met een sinus functie. Je moet alleen zorgen dat de amplitude afzwakt, dus na iedere slinger moet je die parameter iets kleiner laten worden. Hoe zat het ook al weer... a+bsin(c+dPI), dan was geloof ik b de amplitude, dus die moet steeds kleiner worden, tot ie 0 is. En dat dan iedere seconde. En sjah, de zwaartekracht (normaalkracht) kun je dan weer berekenen met de arm (natuurkundige arm, niet de wijzer) enzo... Zoals je merkt weet ik niet al die formules, kun je wel op wikipedia vinden (of in je binas, als je die nog hebt ). Volgens mij is het een redelijk simpel op te lossen probleem, als je er maar de goede formules bij weet te vinden...

[Verwijderd]

hmz... ik zat te denken dat het eigenlijk nog wel wat complexer gaat worden... Het is namelijk meer een soort trilling in een veer, omdat het niet gewoon slingert, maar de wijzer wordt aan weerszijden tegengehouden... Dus is het volgens mij meer een afzwakkende trilling dan een slingerbeweging... Het ligt allemaal wel dicht tegen elkaar, maar is toch nogal anders. De uitwijking van een trilling kun je berekenen met A sin(2PI f t), waar f de frequentie is, t de tijd op het moment dat je de uitwijking wilt weten, en A de amplitude. Dit is een formule voor de uitwijking uitgezet tegen de tijd. Ervan uitgaande dat de trilling van de seconde wijzer niet langer dan bv. een halve seconde mag duren (anders trilt je wijzer meer dan dat ie iets aanwijst), zou je een aangepaste formule kunnen maken voor de amplitude, ook tegen de tijd uitgezet, iets als A = S * 1/t, waar A de amplitude is en S de uitwijking op t=0 en t dezelfde tijd.
Is dit trouwens wel wat je zoekt of zit ik er heel erg naast?

[Jurgle]

@hydra: Wat jurriebur zegt is wat ik bedoel
@jurriebur: dit is precies wat ik bedoel EN een andere aanpak dan de mijne (met krachten en impulsen)

[DaCoTa]

Je moet de wijzer laten convergeren naar de correcte locatie. Zoek eens op PI of PID controller, dan kom je een heel eind. Als je die goed instelt, krijg je alle slingeringen er gratis bij

[naftebakje]

FF een andere manier (ben ik wel goed in, andere manieren voor hetzelfde probleem:
Om te starten neem je een wijzer die op een bepaalde hoek staat (vb 0°). Dan laat je een progje lopen dat een seconde lang vb 60(*) tussenposities bepaalt van je wijzer (opgeteld met je hoek). Je maakt dus een tabel van 100 afwijkingen, je kan dan wat waardes invullen om bijvoorbeeld hem na 3 keer schommelen (+5°, -4°, +3°, -2°, +1°, 0°; met nog wat tussenwaarden om alles wat vloeiend te maken) stil te laten staan.
Om de tussenwaarden te bepalen kan je ws een goeie benadering maken door de snelheid van de wijzer kwadratisch te vertragen als hij vanaf de juiste waarde naar een afwijkwaarde gaat, en weer kwadratisch te versnellen als hij van de afwijkwaarde weer naar nul gaat. Misschien kan je dit ook in het gedrag van de wijzer programmeren, je geeft je wijzer de afwijkwaarde en de tijd die hij daarvoor heeft, en dan zoekt hij het zelf uit.

Als je die modules werkend krijgt, kan je door veel experimenteren hem instelbaar maken: de grootte van de afwijking, het aantal keer schommelen en de tijd hiervoor (in %).

(*) Je oog kan 25 beelden per seconde van elkaar onderscheiden, maar pas vanaf 60 beelden per seconde wordt het helemaal vloeiend, sneller moet je dus niet werken.