Kontrolliertes Timing
~~~~~~~~~~~~~~~~~~~~~
Hinweis: wann man wo welches Timing braucht muss man sich genau
überlegen
das wird 'nur' 1 tick
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 100 )
|
6 | {
|
7 | // empty
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | t2 = system_get_time(); // API get time
|
12 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
13 | ..
|
14 | ..
|
das werden 3 ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 100 )
|
6 | {
|
7 | // empty
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | asm ("nop"); // "Ersteinrichtung = 1 Tick, Ausführung = 1 Tick"
|
12 |
|
13 | t2 = system_get_time(); // API get time
|
14 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
15 | ..
|
16 | ..
|
das werden 'nur' 4 ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 100 )
|
6 | {
|
7 | // empty
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | asm ("nop");
|
12 | asm ("nop");
|
13 |
|
14 | t2 = system_get_time(); // API get time
|
15 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
16 | ..
|
17 | ..
|
das werden auch 'nur' 3 ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 1 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 |
|
12 | t2 = system_get_time(); // API get time
|
13 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
14 | ..
|
15 | ..
|
das werden 'nur' 5 ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 100 )
|
6 | {
|
7 | // empty
|
8 | mtick++;
|
9 | }
|
10 | // bisher 1 tick
|
11 | asm ("nop"); // 2 ticks
|
12 | asm ("nop"); // + 1 tick
|
13 | asm ("nop"); // + 1 tick
|
14 | // werden 5 ticks!
|
15 |
|
16 | t2 = system_get_time(); // API get time
|
17 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
18 | ..
|
19 | ..
|
;-)
das werden 14 ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 3 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | t2 = system_get_time(); // API get time
|
12 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
13 | ..
|
14 | ..
|
3 x 2 x 2 = 12 + while 3 - 1 = 14
dann mal testen:
1 Durchlauf
1 x 2 x 2 = 4 + while 1 - 1 = 4
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 1 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 |
|
12 | t2 = system_get_time(); // API get time
|
13 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
14 | ..
|
15 | ..
|
sind aber nur 3 ticks
2 Durchläufe
2 x 2 x 2 = 8 + while 2 - 1 = 9
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 2 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 |
|
12 | t2 = system_get_time(); // API get time
|
13 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
14 | ..
|
15 | ..
|
sind 9 ticks, ok
5 Durchläufe
5 x 2 x 2 = 20 + while 5 - 1 = 24
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 5 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 |
|
12 | t2 = system_get_time(); // API get time
|
13 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
14 | ..
|
15 | ..
|
sind 24 ticks, ok
das werden ?? ticks bei 100 Durchläufen?
100 x 2 x 2 + while 100 - 1 = 499 ??
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 100 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | t2 = system_get_time(); // API get time
|
12 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
13 | ..
|
14 | ..
|
ups
es werden 598 ticks ;)
mhm
100 x 2 x 2 + while 100 - 1 + "100" - 1 = 598
mhm..
dann nochmal testen:
das werden ?? ticks !
1 | ..
|
2 | t1 = system_get_time(); // API get time
|
3 | // start
|
4 | tick1 = get_ccount(); // Spezial Register CCOUNT Abruf und Übertrag
|
5 | while (mtick < 10 )
|
6 | {
|
7 | asm ("nop");
|
8 | mtick++;
|
9 | }
|
10 |
|
11 | t2 = system_get_time(); // API get time
|
12 | tickdiff = tick2 - tick1; // Wieviel Ticks verbraucht
|
13 | ..
|
14 | ..
|
ticks: 49
10 x 2 x 2 = 40 + while 10 - 1 = 49 .. ok
Wer kommt drauf was zwischen durchlauf 1 und ab 2 anders ist?
;-)
lg
rudi ;-)
"hausaufgaben" müssen sein :)
10 x 2 x 2 = 40 + while 10 - 1 = 49
gegenprobe:
30 durchläufe
30 x 2 x 2 = 120 + while 30 - 1 = 149
und?
Bingo!
40 durchläufe
40 x 2 x 2 = 160 + while 40 - 1 = 199
und?
Bingo!
50 durchläufe
50 x 2 x 2 = 200 + while 50 - 1 = 249
und?
Bingo!
60 durchläufe
60 x 2 x 2 = 240 + while 60 - 1 = 299
und?
Bingo!
70 durchläufe
70 x 2 x 2 = 280 + while 70 - 1 = 349
und?
Bingo!
80 durchläufe
80 x 2 x 2 = 320 + while 80 - 1 = 399
und?
Bingo!
90 durchläufe
90 x 2 x 2 = 360 + while 90 - 1 = 449
und?
Bingo!
100 durchläufe
100 x 2 x 2 = 400 + while 100 - 1 = 499
und?
nö - 598
was ist mit den 100? und 598?
100 x 2 x 2 = 400 + while 100 - 1 = 499
wir haben aber 598?
also step by step
klammer wert ist rechnerischer soll
91 durchläufe = 454 ticks (91*2*2+while 91-1=454)
92 durchläufe = 459 ticks (92*2*2+while 92-1=459)
93 durchläufe = 464 ticks (93*2*2+while 93-1=464)
94 durchläufe = 469 ticks (94*2*2+while 94-1=469)
95 durchläufe = 474 ticks (95*2*2+while 95-1=474)
~~~~~~~~~~~~~~~bis hier her alles ok ~~~~~~~~~~~~~
mhm?
96 durchläufe = 574 ticks (96*2*2+while 96-1=479)
97 durchläufe = 580 ticks (97*2*2+while 97-1=484)
98 durchläufe = 586 ticks (98*2*2+while 98-1=489)
99 durchläufe = 592 ticks (99*2*2+while 99-1=494)
100 durchläufe = 598 ticks (100*2*2+while 100-1=499)
es sind in diesem 'abschnitt' immer 6 ticks mehr als vorherige wert
vorher waren es 5 ticks mehr.
zwischen 95 und 96 durchläufen 'kippt' es
auf
96*2*2+while 96-1 + 100-1
Ein Überlauf um 100 ticks und dann eine differenz weiterer werte um 6.
kippt es bei 2+95 also bei 96 + 95 = 191 durchäufen?
Test
190 durchläufe = 1138 ticks (190*2*2+while 190-1 + 190 - 1 = 1038 )
195 durchläufe = 1168 ticks (195*2*2+while 195-1 + 195 - 1 = 1168 )
200 durchläufe = 1198 ticks (200*2*2+while 200-1 + 200 - 1 = 1198 )
..
1200 ....= 7198 ( = 7198 )
nein, es kippt nicht mehr
warum kippt es bei 95-96?
warum ist es zwischen 1 und ab 2 Durchläufen anders?
Jemand eine Idee bevor Teil 2 'Überlauf' kommt?
:)
Announcement: there is an English version of this forum on 
Thread beobachten
Seitenaufteilung abschalten