Zeitberechnung des Prozesses

[Fughulu (Gast)]

Hallo,

ich habe mir mit meinem 8051 eine Uhr aufgebaut und wollte diese mit 
Assembler lösen, sie läuft auch soweit. Nur bin ich etwas unzufrieden 
mit der genauigkeit der Zeit.
Mich interesssiert es wie ich die Arbeitsdauer des Programmablaufes 
berechnen kann damit ich die Uhr genauer einstellen kann.





Hier mein kompletter Programmcode

;####### Programm für AT89S52 #########;


org 000h
    jmp 0100h         ;Sprung zu Haupt;

org 01bh

    ljmp 0300h       ;Sprung zu Interrupt Zeitschleife



;####### Initialisierung #########;

org 0100h
mov IE,#88h          ;1xEA bit7 und 1x ET1 bit3 (Freigabe Timer 1-interrupt);
mov  PCON,#00h        ;nicht benötigt;
mov SCON,#00h
mov TCON,#00h
mov TMOD,#20h         ;Mode 8-bit-Timer/Counter Reload M1 bit5;
mov TL1,#06h   
mov TH1,#06h      ;Reloadwert für ein 12MHz Oszi, Berechnung: 12M / 12 = 1M= Maschinenzyklus, 1M / 250 = 4 000 Bitwert: 256-250 = 6;
mov TH1,#06h
setb TR1             ;start Timer 1;

mov P0,#00h         ;Nullsetzen;
mov P1,#00h
mov P2,#00h
mov P3,#00h
mov R0,#00h
mov R7,#0160           ;R7 für Zeitberechnung 4 000 / 160 = 25 deshalb Register Vorladen mit 160 = 64hex;
mov R6,#025         ;R6 für Zeitberechnung 25 / 25 =1 deshalb Register vorladen mit 25 (19hex);
mov R1,#00h
mov R2,#00h
mov R3,#00h
mov R4,#00h
mov R5,#00h

;####### Hauptprogramm #########;

mainloop:
  setb p3.2
  setb p3.3
  jnb p3.2,min
  jnb p3.3,std
    mov a,r7          ; Abfrage ob  Register 7 0 wenn ja Abfrage des 2. Registers auf 0;
    jz wert1
    jmp mainloop
std:                               ; Zum einstellen der Zeit von hier...;
  cjne r3,#02,stdn20
  inc p2
  inc r2
  cjne r2,#04,nzmin
  mov p2,#00
  mov r2,#00
  mov r3,#00
  mov p3,#00
  jmp nzmin
stdn20:
  inc p2
  inc r2
  cjne r2,#10,nzmin
  mov p2,#00
  mov r2,#00
  inc r3
  inc p3
  jmp nzmin
  
min:
  inc p0
  inc r0
  cjne r0,#10,nzmin
  mov p0,#00
  mov r0,#00
  inc p1
  inc r1
  cjne r1,#06,nzmin
  mov p1,#00
  mov r1,#00
nzmin:
  mov r5,250
  mov r4,250
loop1:
  djnz r5,loop1
  djnz r4,loop1
  mov r5,250
  mov r4,250
loop2:  
  djnz r5,loop2
  djnz r4,loop2
  jmp mainloop       ; ...Bis hier nur für Zeit einstellen;
wert1:
    mov r7,#160    ;Reloadwert für Register 7 ( 4 000 Hz / 160);
    dec r6
    mov a,r6
    jz Sekundentakt
    jmp mainloop

Sekundentakt:    
  mov r6,#25         ;Reloadwert für Register 2 (25Hz /25);
  inc r4
  cjne r4,#060,mainloop   ;Minutentakt #60;
  mov r4,#00
  inc p0
  inc r0
  cjne r0,#10,mainloop   ;Zehnerminutentakt #10;
  mov p0,#00
  mov r0,#00
  inc p1
  inc r1
  cjne r1,#06,mainloop    ;Stunde #60;
  mov p1,#00
  mov r1,#00
  cjne r3,#02,nichtzwanzig    ;Stunde nicht im 20 Uhr Bereich;
  inc p2
  inc r2
  cjne r2,#04,main2
  mov p2,#00
  mov r2,#00
  mov r3,#00
  mov p3,#00
  ljmp mainloop
nichtzwanzig:
  inc p2
  inc r2
  cjne r2,#010,main2
  mov r2,#00
  mov p2,#00
  inc r3
  inc p3
main2:
  ljmp mainloop


;##### Interrupt Zeitschleife###;

org 0300h

    dec r7       ;Register 7 erhöhen bei jeden Interrupt;

    reti

[Karl H. (kbuchegg)]

Fughulu schrieb:

> Mich interesssiert es wie ich die Arbeitsdauer des Programmablaufes
> berechnen kann damit ich die Uhr genauer einstellen kann.

Schwierig, weil du alle Codepfade inkl. aller Verzweigungen 
berücksichtigen musst.

Hat dein µC keine Hardware-Timer?
Die sind normalerweise das Mittel der Wahl, wenn man Zeitsachen machen 
will. Denn Hardware-Timer arbeiten losgelöst vom Programm und lösen bei 
bestimmten Zählerständen eine Interrupt-Bearbeitung aus. Und das auf den 
Timer-Takt genau.

[Karl H. (kbuchegg)]

Moment.
Du benutzt ja einen Timer.

Dann dürfte das für dich interessant sein. Ist zwar für einen anderen 
Prozessor, aber das Prinzip ist dasselbe.

AVR - Die genaue Sekunde / RTC

[Wolfgang (Gast)]

Und mit ein bisschen Feinarbeit läßt sich auch die mittlere 
Ungenauigkeit der Quarzfrequenz herauskalibrieren
Beitrag "Die genaue Sekunde / RTC"

[Fughulu (Gast)]

ok vielen Dank ich werde mich mal schlaulesen.

[amateur (Gast)]

1. Die meisten Verzweigungsbefehle brauchen je nach Entscheidung
   (linear weiter oder Sprung) unterschiedlich viele Takte.
2. Möglicherweise ist sogar deshalb der "Weg" länger oder kürzer
   (mehr oder weniger Befehle in der Sequenz).
3. Wüstest Du also vorher was Sache ist, brauchtest Du die
   Verzweigungen ja nicht.

Also: Die Laufzeit ist abhängig von Deinen tatsächlichen/aktuellen
      Daten.
      Die lässt sich zwar, für einen konkreten Zustand bestimmen, aber
      nicht pauschal.

Es gibt zwar die Möglichkeit durch das Einfügen von Hilfsschritten wie 
z.B. NOP die Wege anzupassen, aber die Wartung eines solchen 
Codeabschnittes ist eine reine Sisyphusarbeit. Normalerweise geht das 
aber nur in Assembler.