Verständnisfrage zum Match ARM7

Es gibt keinen µC "ARM7". Es gibt nur ein paar Prozessorkerne mit diesem 
Namen, die von zig Herstellern in hunderte von µC eingebaut werden.

Merve B. schrieb:
> Aber ehrlich gesagt, denke ich, dass meine Rechnung ziemlich falsch ist.
> Wäre nett, wenn mich jemand auf meinen Fehler aufmerksam macht.

Korrekt.
Erst einmal das offensichtliche: 1s = 10^6µs
Ich wage aber zu bezweifeln, dass dein Controller mit 14,4MHz läuft. Das 
klingt mir eher, als hättest du die PLL falsch bzw. sinnfrei 
konfiguriert.
Von deiner Timerkonfiguration wissen wir auch nicht allzu viel.

Ich rate jetzt einfach mal ins Blaue:
LPC23xx/24xx mit 288MHz PLL-Frequenz und Postscaler 20?

Wenn deine Angaben allerdings stimmen, dann frage ich mich, warum du für 
das einfache hochzählen einer Variable einen ARM7 benutzt...

@A.K. tut mir leid, dass ich mich falsch ausgedrückt habe

@ Frank Bär Ich habe hier einen LPC2368. Der CPU-Takt beträgt 57.6MHz 
und das dann durch 4 sind 14,4MHz (So wurde es mir erklärt). Ich habe 
nichts an den Einstellungen geändert.
Ich will nur das Prinzip mit dem Match Compare verstehen. Im groben habe 
ich es verstanden, aber mit der Berechnung klappts noch nicht so ganz, 
wie man es sehen kann.
Ich habe auch noch nicht angefangen ein Programm zu schreiben, d.h. 
meinen Timer habe ich noch nicht konfiguriert.

Tut mir leid, wenn ich euch auf die Nerven gehe, mit dem wenigen Wissen, 
was ich habe.

Merve B. schrieb:
> @ Frank Bär Ich habe hier einen LPC2368. Der CPU-Takt beträgt 57.6MHz
> und das dann durch 4 sind 14,4MHz (So wurde es mir erklärt). Ich habe
> nichts an den Einstellungen geändert.

Ah, jetzt nähern wir uns der Sache ;-)

> Ich will nur das Prinzip mit dem Match Compare verstehen. Im groben habe
> ich es verstanden, aber mit der Berechnung klappts noch nicht so ganz,
> wie man es sehen kann.

Wenn der Timerstand den im Match-Register hinterlegten Wert erreicht, 
wird ein Interrupt ausgelöst. In dem Interrupt kannst du deine Variable 
modifizieren.

> Ich habe auch noch nicht angefangen ein Programm zu schreiben, d.h.
> meinen Timer habe ich noch nicht konfiguriert.

Dann solltest du damit anfangen. Für den Anfang ist es erst einmal 
wichtig, dass der Timer läuft. Zu dem Zweck erst einmal minimal 
konfigurieren und starten. Im Debugger schaust du dir dann das 
TC-Register an, ob es sich verändert. Dann kannst du mit dem 
Match-Interrupt rumspielen.

> Tut mir leid, wenn ich euch auf die Nerven gehe, mit dem wenigen Wissen,
> was ich habe.

Jeder fängt mal an.

Ein Oszilloscope oder auch nur ein Frequenzzähler wär jetzt für diese 
Aufgabe auch nicht verkehrt. Damit kannst du dann deine Einstellungen 
verifizieren.

Grüsse

Danke für die Hilfestellungen. Ich habe ein kleines Programm geschrieben 
was auch funktioniert. Ich poste es mal rein, vielleicht braucht es 
irgendwann mal jemand. Falls ihr Fehler seht, dann könnt ihr mich gerne 
darauf aufmerksam machen.

1

/*----------------------------------------------------------------------------

2

 * Name:    main.c

3

 *----------------------------------------------------------------------------*/

4

5

#include <LPC23xx.h>           /* LPC23xx definitions */

6

#include "LPC2xxx_embedded.h"

7

8

pLPC_TIMER_TypeDef  pTimer;

9

pLPC_VIC_TypeDef  VIC_Controller_basis;

10

11

int zeit1;

12

13

__irq void timer0_ISR (void);

14

15

__irq void timer0_ISR (void)

16

{

17

  pTimer->TIR = 0x01;

18

  zeit1++;

19

  pTimer-> TTCR = 1; //Timer starten

20

  VIC_Controller_basis->VIC_Address = 0;

21

}

22

23

void init_Timer0(void)

24

{

25

26

  //Initialize Timer

27

28

  zeit1=0;

29

  pTimer->TIR = 0x01; //

30

  pTimer->TMCR = 0x03; // interrupt on MR0 & Reset TC if Match

31

  pTimer->TMR0 = 0xDBB9FF; //Einstellung auf 1s

32

  pTimer-> TTCR = 1; //Timer starten

33

//  pTimer->TMCR = 0x03; //Interrupt on MR0 & reset TC if match on MR0

34

35

}

36

37

void vic_init(void)

38

{

39

  VIC_Controller_basis->VIC_VectAddress[4] = (unsigned long)timer0_ISR;   //Vektor

40

    VIC_Controller_basis->VIC_VectPriority[4] = 0x0000000A;    //Priorität

41

    VIC_Controller_basis->VIC_IntEnable |= (1 << 4);    //Interrupt  freigeben für Timer0

42

}

43

44

int main(void)

45

{  

46

  pTimer = TIMER0_BASE;

47

  VIC_Controller_basis = VIC_BASE;

48

  init_Timer0();

49

  vic_init();

50

  while (1)

51

  {

52

53

  }

54

55

}

Ach ja eine kleine Frage hätte ich da noch. Muss ich in der ISR den 
Timer noch einmal starten?

Gruß

Merve B. schrieb:
> Ach ja eine kleine Frage hätte ich da noch. Muss ich in der ISR den
> Timer noch einmal starten?

Nein, der Timer läuft weiter.

@Frank Bär
Danke :)

Ich möchte noch eine Kleinigkeit wissen. Wenn ich vom selben Timer 2 
Interrupts haben möchte (einmal mit Match und einmal mit Capture), dann 
muss ich doch praktisch bei der Initialisierung von den Vektoren "2 
Interrupt Vektoren" zuweisen, richtig? Aber wenn beides vom selben Timer 
ist kann ich dann trotzdem die selbe Vektor Adresse benutzen ( in dem 
Fall jetzt die "4")? Weil im Datenblatt steht da nur die "4" für den 
Timer0.

Du musst dazu zusätzlich die Interrupt-Quelle prüfen. Im IR-Register 
prüfst du auf das MR0-Bit bzw. auf das CR0-Bit. Abhängig davon muss 
deine ISR dann den entsprechenden Code ausführen.

Im IR-Register habe ich den Capture Interrupt und den Match Interrupt 
ausgewählt. Desweiteren habe ich bei der Initialisierung von den 
Interrupt Vektoren den "Block" kopiert und nur die Prioriät geändert. 
Aber ehrlich gesagt, weiß ich nicht, wie er in die richtige ISR 
reinspringen kann.

Es gibt nur eine ISR, nämlich die, die dem Interruptvektor 4 zugeordnet 
ist.
In der ISR musst du jetzt prüfen, ob die Capture-Bedingung (Flag CR0) 
oder die Matchbedingung (Flag MR0) den Interrupt ausgelöst hat.
Die Bits, die du prüfen musst, findest du in TnIR.
In der Konfiguration musst du in TnCCR den Capture-Interrupt aktivieren 
und in TnMCR den Match-Interrupt.

Ah klingt logisch :) Danke für den Tipp!!!

@Frank Bär
Danke für den tollen Tipp. Hab es ausprobiert und es klappt wunderbar. 
Was mich nur irritiert, ich habe in einem anderen Projekt den Timer mit 
der Matchfunktion getestet. Wie zu erwarten hat er jede Sekunde eine 
Variable hochgezählt. Bloß als ich es dann in das Programm mit dem 
Capture eingebaut habe, habe ich plötzlich viel zu hoche Zahlen 
zurückbekommen, obwohl ich die selbe Konfiguration genommen habe, wie in 
dem funktionierendem Programm.
Weißt du vielleicht, an was das liegen kann?
Danke

Traten die hohen Werte auf deiner Zählvariable auf?
Dann hast du wahrscheinlich auch bei jedem Capture-Event inkrementiert, 
weil die ISR nicht zwischen Match- und Capture-Event differenziert hat.
Näheres kann man nur sagen, wenn du den Code der ISR zeigst.

Ich habe vergessen, den Interrupt-Flag zu löschen.
Als ich das tat, waren die Werte wieder in Ordnung.
Mein Fehler ;) aber man lernt ja dadurch :)