Frequenz messen (260 Hz)

[Horst (Gast)]

Hallo zusammen,

ich möchte mit einem PIC12, den ich bei 1 Mhz laufen lasse ein 
Taktsignal ausmessen. Irgendwie schwankt mein Ergebnis aber gravierend, 
daher an euch die Frage, ob ihr wisst, woran das liegen kann.
Mein Signal hat eine Frequenz von ca. 264 Hz (Tsignal = 3,78 ms).
Ich messe, indem ich einen 16 bit Timer mit Ttimer = 7,99 µs pro 
Inkrement starte, mit

for(i=0; i<16; i++)
{
while(RA5);
while(!RA5);
}

16 Durchläufe abwarte, und dann meinen Timer auslese (inklusive 
eventuellen Overflows).

Nach den 16 Durchläufen sollte ich nun doch eigentlich einen Wert von 
ca. 7570 aus dem Timer lesen (16 * Tsignal / Ttimer), tatsächlich 
bekomme ich aber nur etwa die Hälfte und das Ergebnis schwankt obendrein 
wie gesagt gravierend. Was meint ihr dazu?

[Fuerst-Rene (Gast)]

264 HZ kannst du mit Kopfhörern oder kleinem Lautspr. noch hören ohne 
verstärker. Damit weist du obs schwankt.
Gibts bei dem Proz auch ein ANSELA Register?
Der macht bei nichtabfrage einen Analogen Eingang draus.

[Markus W. (Firma: guloshop.de) (m-w)]

Horst schrieb:
> bekomme ich aber nur etwa die Hälfte und das Ergebnis schwankt obendrein
> wie gesagt gravierend. Was meint ihr dazu?

Wie sehr schwankt denn dein Ergebnis? Wenn es weniger als 1/16 der 
Frequenz ist, kann das daran liegen, dass du vor den Beginn deiner 
Mess-Schleife ein

while(RA5); while(!RA5);

setzen solltest, um einen definierten Startzeitpunkt für deine Messung 
zu erhalten.

[Krapao (Gast)]

Es kann passieren, dass du irgendwo in die erste Periode einsteigst und 
dadurch zu knapp misst. Der Fehler davon ist worst-case (Signal bei 
Beginn der for-Schleife im letzten Zucken der Low-Halbperiode) 1/16-tel 
deiner Messfrequenz, also rund 16 Hz.

Bei dem halben Timerwert würde ich als erstes meine Initialisierung des 
Timers überprüfen, ob die angenommenen 7,99 µs auch stimmen.

[Horst (Gast)]

Fuerst-Rene schrieb:
> 264 HZ kannst du mit Kopfhörern oder kleinem Lautspr. noch hören ohne
> verstärker. Damit weist du obs schwankt.
Nicht nötig, habe es mit Oszi überprüft :)

Fuerst-Rene schrieb:
> Gibts bei dem Proz auch ein ANSELA Register?
> Der macht bei nichtabfrage einen Analogen Eingang draus.
Ein ANSELA Register gibt es, aber es ist alles auf 0 für I/O gesetzt.

Markus W. schrieb:
> Wie sehr schwankt denn dein Ergebnis? Wenn es weniger als 1/16 der
> Frequenz ist, kann das daran liegen, dass du vor den Beginn deiner
> Mess-Schleife ein
while(RA5); while(!RA5);
>setzen solltest, um einen definierten Startzeitpunkt für deine Messung
> zu erhalten.
Das Ergebnis schwankt zwischen 2700-4000 und sogar darüber hinaus. An 
den Startzeitpunkt habe ich auch gedacht und es genau so gemacht, wie du 
beschrieben hast. Habe ich vergessen zu erwähnen.

Krapao schrieb:
> Bei dem halben Timerwert würde ich als erstes meine Initialisierung des
> Timers überprüfen, ob die angenommenen 7,99 µs auch stimmen.
Den Timer habe ich auch mit Oszi geprüft.

Vielen Dank für die Tips, leider klappt es immer noch nicht. Habt ihr 
noch eine Idee?

[Krapao (Gast)]

Sorry, mehr fällt mir zu dem gezeigten Code nicht ein.

[Michael R. (mexman)]

Hallo,

zeig doch mal den Assemblercode!


Gruss

Michael

[Horst (Gast)]

Michael Roek schrieb:
> zeig doch mal den Assemblercode!
Von Assembler habe ich leider keine Ahnung und weiß nicht genau was du 
brauchst. Ich habe das projekt nun extra nochmal neu angelegt, nur mit 
den relevanten Funktionen. Unten ist nun der Assembler Code dazu. Ich 
habe nicht alles kopiert, was der Compiler ausgespuckt hat, ich hoffe 
die relevanten Sachen sind dabei. Wenn nicht, sag Bescheid, dann schicke 
ich nochmal alles...

Vorher nochmal Zusatzinfos: Ich habe es gerade mal anders herum 
ausprobiert: in einem gesamten Timer Durchlauf (ca. 520 ms) die I/O 
steps (ca. 3,7 ms) gezählt. Also

while(1)
{
while(RA5);
while(!RA5);
i++;
}

Dann in der ISR des Timers i abgefragt, und komischerweise liegt i statt 
der erwarteten 140 ca. bei 280, aber auch stark schwankend. Auffallend 
fand ich den Faktor 2 der in beiden Fällen Probleme macht.

Hier jetzt der Assembler code:

1:                 #include"globals.h"
2:                   
3:                 
4:                 void Get_Speed(void)
5:                 {  
6:                   unsigned int time;
7:                   unsigned int overflow;
8:                   unsigned char i;
9:                   
10:                  while(RA5);
   789    2F8A     GOTO 0x78a
   78A    0020     MOVLB 0
   78B    1A8C     BTFSC 0xc, 0x5
   78C    2F8E     GOTO 0x78e
   78D    2F8F     GOTO 0x78f
   78E    2F8A     GOTO 0x78a
   78F    2F91     GOTO 0x791
11:                  while(!RA5);          //wait for toggle to high
   790    2F91     GOTO 0x791
   791    1E8C     BTFSS 0xc, 0x5
   792    2F94     GOTO 0x794
   793    2F95     GOTO 0x795
   794    2F91     GOTO 0x791
   795    2F96     GOTO 0x796
12:                  time = (TMR1H << 8) + TMR1L;  //Timer1 start time
   796    0816     MOVF 0x16, W
   797    00F6     MOVWF 0x76
   798    01F7     CLRF 0x77
   799    0817     MOVF 0x17, W
   79A    00F8     MOVWF 0x78
   79B    01F9     CLRF 0x79
   79C    0878     MOVF 0x78, W
   79D    00F9     MOVWF 0x79
   79E    01F8     CLRF 0x78
   79F    0876     MOVF 0x76, W
   7A0    0778     ADDWF 0x78, W
   7A1    00A2     MOVWF 0x22
   7A2    0877     MOVF 0x77, W
   7A3    3D79     ADDWFC 0x79, W
   7A4    00A3     MOVWF 0x23
13:                  overflow = timer1_overflow;    //Timer1 start overflow
   7A5    0828     MOVF 0x28, W
   7A6    01A1     CLRF 0x21
   7A7    07A1     ADDWF 0x21, F
   7A8    0827     MOVF 0x27, W
   7A9    01A0     CLRF 0x20
   7AA    07A0     ADDWF 0x20, F
14:                  for(i=0;i<16;i++)        //16 changes = 2 rotations (8 pole pairs)
   7AB    01A4     CLRF 0x24
   7AC    3010     MOVLW 0x10
   7AD    0224     SUBWF 0x24, W
   7AE    1C03     BTFSS 0x3, 0
   7AF    2FB1     GOTO 0x7b1
   7B0    2FB2     GOTO 0x7b2
   7B1    2FB5     GOTO 0x7b5
   7B2    2FCB     GOTO 0x7cb
   7B3    2FCB     GOTO 0x7cb
   7C0    3001     MOVLW 0x1
   7C1    00F6     MOVWF 0x76
   7C2    0876     MOVF 0x76, W
   7C3    07A4     ADDWF 0x24, F
   7C4    3010     MOVLW 0x10
   7C5    0224     SUBWF 0x24, W
   7C6    1C03     BTFSS 0x3, 0
   7C7    2FC9     GOTO 0x7c9
   7C8    2FCA     GOTO 0x7ca
   7C9    2FB5     GOTO 0x7b5
   7CA    2FCB     GOTO 0x7cb
15:                  {
16:                    while(RA5);    
   7B4    2FB5     GOTO 0x7b5
   7B5    1A8C     BTFSC 0xc, 0x5
   7B6    2FB8     GOTO 0x7b8
   7B7    2FB9     GOTO 0x7b9
   7B8    2FB5     GOTO 0x7b5
   7B9    2FBB     GOTO 0x7bb
17:                    while(!RA5);  
   7BA    2FBB     GOTO 0x7bb
   7BB    1E8C     BTFSS 0xc, 0x5
   7BC    2FBE     GOTO 0x7be
   7BD    2FBF     GOTO 0x7bf
   7BE    2FBB     GOTO 0x7bb
   7BF    2FC0     GOTO 0x7c0
18:                  }  
19:                
20:                  time = (TMR1H << 8) + TMR1L + 0xFFFFFFFF - time + ((timer1_overflow - overflow) * 65535);  // * 0.0000079 for time in sec. 
   7CB    0922     COMF 0x22, W
   7CC    00F6     MOVWF 0x76
   7CD    0923     COMF 0x23, W
   7CE    00F7     MOVWF 0x77
   7CF    0AF6     INCF 0x76, F
   7D0    1903     BTFSC 0x3, 0x2
   7D1    0AF7     INCF 0x77, F
   7D2    0920     COMF 0x20, W
   7D3    00F8     MOVWF 0x78
   7D4    0921     COMF 0x21, W
   7D5    00F9     MOVWF 0x79
   7D6    0AF8     INCF 0x78, F
   7D7    1903     BTFSC 0x3, 0x2
   7D8    0AF9     INCF 0x79, F
   7D9    0827     MOVF 0x27, W
   7DA    0778     ADDWF 0x78, W
   7DB    00F0     MOVWF 0x70
   7DC    0828     MOVF 0x28, W
   7DD    3D79     ADDWFC 0x79, W
   7DE    00F1     MOVWF 0x71
   7DF    30FF     MOVLW 0xff
   7E0    00F2     MOVWF 0x72
   7E1    30FF     MOVLW 0xff
   7E2    00F3     MOVWF 0x73
   7E3    3187     MOVLP 0x7
   7E4    2765     CALL 0x765
   7E5    3187     MOVLP 0x7
   7E6    0870     MOVF 0x70, W
   7E7    0020     MOVLB 0
   7E8    0716     ADDWF 0x16, W
   7E9    00FA     MOVWF 0x7a
   7EA    0871     MOVF 0x71, W
   7EB    3D17     ADDWFC 0x17, W
   7EC    00FB     MOVWF 0x7b
   7ED    0876     MOVF 0x76, W
   7EE    077A     ADDWF 0x7a, W
   7EF    00FC     MOVWF 0x7c
   7F0    0877     MOVF 0x77, W
   7F1    3D7B     ADDWFC 0x7b, W
   7F2    00FD     MOVWF 0x7d
   7F3    087C     MOVF 0x7c, W
   7F4    3EFF     ADDLW 0xff
   7F5    00A2     MOVWF 0x22
   7F6    30FF     MOVLW 0xff
   7F7    3D7D     ADDWFC 0x7d, W
   7F8    00A3     MOVWF 0x23
21:                
22:                
23:                  new_max_speed = time;    //16 Steps, 8 pole pairs -> 7.5/time 
   7F9    0823     MOVF 0x23, W
   7FA    01A6     CLRF 0x26
   7FB    07A6     ADDWF 0x26, F
   7FC    0822     MOVF 0x22, W
   7FD    01A5     CLRF 0x25
   7FE    07A5     ADDWF 0x25, F
24:                }
   7FF    0008     RETURN
---  C:\Daten\gepr\forum\Init.c  -----------------------------------------------------------------
1:                 #include "globals.h"
2:                 
3:                 void Init(void)
4:                 {  
5:                   TRISA = 0b11101110;
   732    30EE     MOVLW 0xee
   733    0021     MOVLB 0x1
   734    008C     MOVWF 0xc
6:                   ANSELA = 0x00;
   735    0023     MOVLB 0x3
   736    018C     CLRF 0xc
7:                 
8:                   INTCONbits.PEIE = 1;        
   737    170B     BSF 0xb, 0x6
9:                   INTCONbits.GIE = 1;  
   738    178B     BSF 0xb, 0x7
10:                  
11:                  OSCCON = 0b01101000;    //bit7: PLL,  bit6-3: 4 MHz internal Clock,  bit2: not implemented, bit1-0 Dont care cause __CONFIG(INTOSC_ON);
   739    3068     MOVLW 0x68
   73A    0021     MOVLB 0x1
   73B    0099     MOVWF 0x19
12:                
13:                  timer1_overflow = 0;
   73C    0020     MOVLB 0
   73D    01A7     CLRF 0x27
   73E    01A8     CLRF 0x28
14:                  PIE1bits.TMR1IE = 1;      //Timer1 Overflow Enable
   73F    0021     MOVLB 0x1
   740    1411     BSF 0x11, 0
15:                  T1CON |= 0b00110000;      //Prescaler: 1:8
   741    3030     MOVLW 0x30
   742    00F0     MOVWF 0x70
   743    0870     MOVF 0x70, W
   744    0020     MOVLB 0
   745    0498     IORWF 0x18, F
16:                  TMR1H = 0;            //Set Timer1 value
   746    0197     CLRF 0x17
17:                  TMR1L = 0;            //Set Timer1 value
   747    0196     CLRF 0x16
18:                  T1CONbits.TMR1ON = 1;      //Timer1 start  
   748    1418     BSF 0x18, 0
19:                }
   749    0008     RETURN

:                 #include "globals.h"
2:                 
3:                 __CONFIG(FOSC_INTOSC & WDTE_OFF);
4:                 __CONFIG(LVP_OFF & BORV_25 & STVREN_ON & PLLEN_ON);          
5:                       
6:                 unsigned int timer1_overflow = 0;  
7:                 
8:                 void main(void)
9:                 {
10:                  Init();  
   74A    3187     MOVLP 0x7
   74B    2732     CALL 0x732
   74C    3187     MOVLP 0x7
   74D    2F4E     GOTO 0x74e
11:                  while(1)
   762    2F4E     GOTO 0x74e
12:                  {
13:                    Get_Speed();
   74E    3187     MOVLP 0x7
   74F    2789     CALL 0x789
   750    3187     MOVLP 0x7
14:                    if(new_max_speed > 4000)
   751    300F     MOVLW 0xf
   752    0020     MOVLB 0
   753    0226     SUBWF 0x26, W
   754    30A1     MOVLW 0xa1
   755    1903     BTFSC 0x3, 0x2
   756    0225     SUBWF 0x25, W
   757    1C03     BTFSS 0x3, 0
   758    2F5A     GOTO 0x75a
   759    2F5B     GOTO 0x75b
   75A    2F5E     GOTO 0x75e
15:                      LATA4 = 1;
   75B    0022     MOVLB 0x2
   75C    160C     BSF 0xc, 0x4
   75D    2F4E     GOTO 0x74e
16:                    else
17:                      LATA4 = 0;
   75E    0022     MOVLB 0x2
   75F    120C     BCF 0xc, 0x4
   760    2F4E     GOTO 0x74e
   761    2F4E     GOTO 0x74e
18:                
19:                  }        
20:                }
   763    3180     MOVLP 0

[Karl H. (kbuchegg)]

Horst schrieb:
> Michael Roek schrieb:
>> zeig doch mal den Assemblercode!
> Von Assembler habe ich leider keine Ahnung und weiß nicht genau was du
> brauchst.

Das dürfte auch eine Fehlinformation gewesen sein. Da du in C 
programmierst, sollten wir erst mal das Naheliegenste kontrollieren: Du 
hast einen Fehler im C-Programm. Und dazu braucht man das C-Programm.
Und zwar nicht nur einen winzigen Ausschnitt, sondern komplett.

[Udo S. (urschmitt)]

Sicher daß dein Signal ein sauberer Rechteck ist und keine Störungen 
(Peaks) enthält?

Signalquelle?
Schaltungsaufbau?

[Michael R. (mexman)]

Hallo Horst,

> 11:                  while(!RA5);          //wait for toggle to high
>    790    2F91     GOTO 0x791
>    791    1E8C     BTFSS 0xc, 0x5
>    792    2F94     GOTO 0x794
>    793    2F95     GOTO 0x795
>    794    2F91     GOTO 0x791
>    795    2F96     GOTO 0x796

ich habe ersty spaeter Zeit, mal in Ruhe  ueber die Initalisierung zu 
gehen, aber hier oben z.B: ist schon erkennbar, dass je nachdem zu 
welchem Zeitpunkt  Dein Eingangssignal den Zustand wechselt (vor Zeile 
791 oder danach) einige Codezeilen mehr oder weniger ausgefuehrt werden.
Dennoch duefte das bei der Takt- und der EIngangsfrequenz nicht so 
erheblich sein wie Du das beschreibst. Ich schaue spaeter nochmal 
rein....




@Karl-Heinz: Beim Assemblercode steht ka das C-Programm dabei

Gruss

Michael

[Horst (Gast)]

Karl Heinz Buchegger schrieb:
> Und dazu braucht man das C-Programm.
> Und zwar nicht nur einen winzigen Ausschnitt, sondern komplett.

Wird gemacht :)

#include "globals.h"

__CONFIG(FOSC_INTOSC & WDTE_OFF);
__CONFIG(LVP_OFF & BORV_25 & STVREN_ON & PLLEN_ON);          
unsigned int timer1_overflow = 0;  

void main(void)
{
  Init();  
  while(1)
  {
    Get_Speed();
    if(new_max_speed > 4000)
      LATA4 = 1;
    else
      LATA4 = 0;
  }        
}

///////////////////////////////////////INIT/////////////////////
#include "globals.h"
void Init(void)
{  
  TRISA = 0b11101110;
  ANSELA = 0x00;

  INTCONbits.PEIE = 1;        
  INTCONbits.GIE = 1;  
  
  OSCCON = 0b01101000;    
  timer1_overflow = 0;
  PIE1bits.TMR1IE = 1;      //Timer1 Overflow Enable
  T1CON |= 0b00110000;      //Prescaler: 1:8
  TMR1H = 0;          //Set Timer1 value
  TMR1L = 0;          //Set Timer1 value
  T1CONbits.TMR1ON = 1;      //Timer1 start  
}

/////////////////////////////GET_SPEED///////////////////
#include"globals.h"
void Get_Speed(void)
{  
  unsigned int time;
  unsigned int overflow;
  unsigned char i;
  
  while(RA5);
  while(!RA5);          //wait for toggle to high
  time = (TMR1H << 8) + TMR1L;  //Timer1 start time
  overflow = timer1_overflow;    //Timer1 start overflow
  for(i=0;i<16;i++)        //16 changes = 2 rotations (8 pole pairs)
  {
    while(RA5);    
    while(!RA5);  
  }  

  time = (TMR1H << 8) + TMR1L + 0xFFFFFFFF - time + ((timer1_overflow - overflow) * 65535);  

  new_max_speed = time;    //16 Steps, 8 pole pairs -> 7.5/time 
}
///////////////////////GLOBALS.H/////////////////////////////////


#include <htc.h>
#include "defines.h"

static void interrupt ISR(void);
void Init(void);
void Get_Speed(void);

unsigned int timer1_overflow;

unsigned int new_max_speed;

Udo Schmitt schrieb:
> Sicher daß dein Signal ein sauberer Rechteck ist und keine Störungen
> (Peaks) enthält?
>
> Signalquelle?
> Schaltungsaufbau?

[Michael R. (mexman)]

Hallo Horst,

Kannst Du das denn nicht erst mal im  Simulator laufen lassen und sehen 
was passiert?
Oder besser im Emulator?
Dort ein paar Breakpoints setzen und den Programmzaehler 
beobachten....Gruss

Michael

[Horst (Gast)]

Udo Schmitt schrieb:
> Sicher daß dein Signal ein sauberer Rechteck ist und keine Störungen
> (Peaks) enthält?
>
> Signalquelle?
> Schaltungsaufbau?

Es ist leider kein sauberes Rechtecksignal, sondern was ganz eigenes. 
Die ansteigende Flanke "zittert" etwas. Und gerade habe ich mal einen 
I/O toggeln lassen mit jeder Flanke, die erkannt wird, und siehe da, die 
Hysterese von meinem Pin ist zu klein. Der schaltet bevor er endgültig 
High geht nochmal ganz kurz auf Low. Konnte ich erst sehen, als ich ganz 
nah herangezoomt habe. Damit dürfte das Problem wohl gegessen sein :)
Vielen vielen Dank an euch alle!

@ Michael Roek
Das ist natürlich auch interessant. Dann muss ich mal sehen, wie genau 
es am ende wird und abklären, wie genau ich es brauche. Wenn es zu 
ungenau ist, komme ich hier nochmal darauf zurück. Vorerst brauchst du 
dir also keine weitere Mühe machen.

Nochmal vielen Dank an alle!

[(prx) A. K. (prx)]

Horst schrieb:

>   while(RA5);
>   while(!RA5);          //wait for toggle to high
>   time = (TMR1H << 8) + TMR1L;  //Timer1 start time

Zwischen den kritischen Zeilen nur auslesen und in Variablen speichern. 
Zusammenrechnen kannst du sie später.

[Horst (Gast)]

Michael Roek schrieb:
> Kannst Du das denn nicht erst mal im  Simulator laufen lassen und sehen
> was passiert?

Das wäre wegen dem sehr eigentümlichen Eingangssignal nicht so sinnig 
gewesen. Habe ich vergessen gleich zu erwähnen, tut mir leid.

[Horst (Gast)]

A. K. schrieb:
> Zwischen den kritischen Zeilen nur auslesen und in Variablen speichern.
> Zusammenrechnen kannst du sie später.

Danke für den Tipp, wird umprogrammiert :)

[Udo S. (urschmitt)]

Horst schrieb:
> Es ist leider kein sauberes Rechtecksignal, sondern was ganz eigenes.
> Die ansteigende Flanke "zittert" etwas. Und gerade habe ich mal einen
> I/O toggeln lassen mit jeder Flanke, die erkannt wird, und siehe da, die
> Hysterese von meinem Pin ist zu klein. Der schaltet bevor er endgültig
> High geht nochmal ganz kurz auf Low. Konnte ich erst sehen, als ich ganz
> nah herangezoomt habe. Damit dürfte das Problem wohl gegessen sein :)
> Vielen vielen Dank an euch alle!

Schön, dann habe ich heute wenigstens einmal was nützliches gemacht.
Kann ich jetzt wenigstens mit einem guten Gefühl hier an meinem Sch... 
weitermachen :-)

[Krapao (Gast)]

>   time = (TMR1H << 8) + TMR1L;  //Timer1 start time

Das ist auf dem PIC12 kein atomarer Zugriff. Siehe die Hinweisbox dazu 
im Datenblatt.

Um das sauber zu machen, darf während des Auslesens des 16-Bit Registers 
kein Timerinterrupt kommen. Also diesen lokal sperren! Das Verfahren von 
Horst vermindert die Chance, dass TMR1H und TMR1L asynchron gelesen 
werden, vorkommen kann es trotzdem.

> TMR1H und TMR1L vs. timer1_overflow

Gleiches Problem nur seltener. Zusätzlich solltest du dem Compiler 
mitteilen, dass timer1_overflow volatile ist.

> unsigned int time;
> time = (TMR1H << 8) + TMR1L + 0xFFFFFFFF - time + ((timer1_overflow -
>        overflow) * 65535);

Wieviele Bit hat unsigned int auf dem PIC12?

Deine Teilausdrücke ((timer1_overflow - overflow) * 65535) und 
0xFFFFFFFF in der Formel sind mir suspekt. Sobald timer1_overflow - 
overflow ungleich 0 ist, bekommst du abenteuerliche Werte.

Die 65535 selbst sind IMHO auch fischig. Ein Overflow heisst, dass 2^16 
= 65536 Timerschritte vergangen sind!

[Krapao (Gast)]

> Das Verfahren von Horst

Jo, ne das "Schnell und kurz Auslesen, später Rechnen" meine ich.
Beitrag "Re: Frequenz messen (260 Hz)"

[Yasin (Gast)]

Krapao schrieb:
> Das ist auf dem PIC12 kein atomarer Zugriff. Siehe die Hinweisbox dazu
> im Datenblatt.
Ich weiß leider nicht welche Hinweisbox du genau meinst aber ich habe es 
jetzt gemacht, wie ihr empfohlen habt. Zuerst auslesen, dann berechnen, 
und außerdem vor dem auslesen den Timer gestoppt.


Krapao schrieb:
> Wieviele Bit hat unsigned int auf dem PIC12?
16

Die Code Zeile ist dir zu Recht suspekt, da stimmt auch was nicht. Für 
alle, die es interessier, seht ihr nochmal die gesamte Funktion. Zuerst 
habe ich die "zittrigen" Flanken versucht per Software zu kompensieren, 
indem ich sie einfach mit einem delay "überspringe". Dadurch wurde es 
zwar deutlich besser, aber irgendwie hatte ich trotzdem noch starke 
Schwankungen, obwohl die Flanken so eigentlich sehr schön erkannt 
werden. Nunja, nun hat erstmal ein 470pF Kerko geholfen. Das ist mir 
allerdings sehr unlieb, weil bei höheren Frequenzen (die später noch 
auftreten werden) das Signal zu stark geglättet werden könnte und ich 
irgendwann nur noch "High" erkenne. Falls also jemand noch eine Idee 
hat, wie ich das Problem per Software in den Griff bekomme...
Das 0xFFFFFFFF ist mein maximaler Timer Wert. Kann ich das auch 
eleganter machen?

void Get_Speed(void)
{  
  unsigned int timer_steps;
  unsigned int overflow_old;
  unsigned int overflow_new;
  unsigned char i;
  unsigned char timerl;
  unsigned char timerh;
  
  while(RA5);
  while(!RA5);    
  T1CONbits.TMR1ON = 0;
        timerl = TMR1L;
  timerh = TMR1H;  
  overflow_old = timer1_overflow;        
  T1CONbits.TMR1ON = 1;            
  timer_steps = (timerh << 8) + timerl;
  for(i=0;i<16;i++)              
  {
    __delay_us(200);    //gegen "zittrige" Flanken
    while(RA5);  
    __delay_us(200);      
    while(!RA5);      
  }  
  T1CONbits.TMR1ON = 0;            
  timerl = TMR1L;
  timerh = TMR1H;
  overflow_new = timer1_overflow;
  T1CONbits.TMR1ON = 1;              

  if(overflow_new - overflow_old) //mehr als 1 Overflow ist nicht möglich
  timer_steps = (timerh << 8) + timerl + 0xFFFFFFFF - timer_steps;  //neuer Wert plus Differenz des alten Wertes bis zum Überlauf
  else 
  timer_steps = (timerh << 8) + timerl - timer_steps;        //neuer Wert minus alter Wert
}

[Karl H. (kbuchegg)]

> if(overflow_new - overflow_old) //mehr als 1 Overflow ist nicht möglich

Wenn du unsigned und alles in 16 Bit rechnest, brauchst du diesen 1 
Overflow überhaupt nicht berücksichtigen. Durch die Definition des 
unsigned-Rechenhandlings kommt trotzdem immer das richtige raus, wenn du 
einfach nur Ende - Anfang rechnest.

[Yasin (Gast)]

Karl Heinz Buchegger schrieb:
> Wenn du unsigned und alles in 16 Bit rechnest, brauchst du diesen 1
> Overflow überhaupt nicht berücksichtigen. Durch die Definition des
> unsigned-Rechenhandlings kommt trotzdem immer das richtige raus, wenn du
> einfach nur Ende - Anfang rechnest.

Achso? Aber wenn ich zum Beispiel bei 60000 starte, einen Überlauf habe, 
und bei 10000 stoppe. Dann hatte ich ja 15535 Schritte. Wenn ich aber 
10000-60000 rechne kommt doch was anderes raus, oder?

[Christian G. (christian_g83)]

Yasin schrieb:

> Wenn ich aber
> 10000-60000 rechne kommt doch was anderes raus, oder?

Richtig. Nämlich 15536.

[Karl H. (kbuchegg)]

Yasin schrieb:

> Achso? Aber wenn ich zum Beispiel bei 60000 starte, einen Überlauf habe,
> und bei 10000 stoppe. Dann hatte ich ja 15535 Schritte.

15536.
Auch der Schritt von 65535 nach 0 ist ein Schritt

> Wenn ich aber
> 10000-60000 rechne kommt doch was anderes raus, oder?

Hast du das schon mal nachgerechnet?
Was kommt den raus?


Aber du hast recht. Ich muss mich präzisieren:

Ausgangssituation: 16 Bit Timer, der seinen vollen Wertebereich 
durchzählt, sowie die Annahme, dass die komplette Berechnung in 16-Bit 
unsigned Arithmetik durchgeführt wird.

Solange es nur 1 Überlauf geben kann UND der Endwert kleiner als der 
Startwert ist, braucht dieser 1 Überlauf nicht berücksichtigt werden.
De facto läuft das darauf hinaus, das der Timer vom Start der 
Messperiode bis zum Ende derselben nicht mehr als maximal 65535 Ticks 
machen darf. Ist dieser Fall gegeben, dann können die Überläufe komplett 
ignoriert werden.
Ein Einbeziehen eines eventuellen Überlaufs würde alles nur 
komplizierter machen und durch das Aufblähen auf 32 Bit Arithmetik auch 
verlangsamen.