Timer_A, Timer_B

[XMEN (Gast)]

hi,
mal eine frage:bei msp430
ich will 2 timer benutzen . also timerA und timerB..
ich will 2 interrupt auslösen. einmal mit timerA und einmal mit B.


mit welchem Befehl kann ich zu den Routinen springen?
als bsp: _EINT(); aber das ist eine allgemeine Interrupt.
// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
..
}


// Timer B0 interrupt service routine
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B (void)
{
..
}


danke im Vorraus...

[Jörg S. (Gast)]

> mit welchem Befehl kann ich zu den Routinen springen?

Du willst einen Befehl mit dem man manuell in die Interrupt Routine 
springen kann?

[XMEN (Gast)]

ja genau, ein befehl dass ich in die interrupt von Timer A springe oder 
in die B.

[Karl heinz B. (kbucheg)]

> ja genau, ein befehl dass ich in die interrupt von Timer A springe
> oder in die B.

Das widerspricht dem Wesen eines Interrupts.
Aber du kannst folgendes machen:

Lagere die Funktionalität der jeweiligen Interrupts in
eine eigene Funktion aus.
Diese Funktion rufst du vom Interrupt Handler auf. Und
natürlich kannst du die Funktion auch von überall
her anders aufrufen.

Darf ich fragen, wozu das gut sein soll?

[XMEN (Gast)]

ich bin kein programmierer und muss den Timer benutzen für eine 
schleife, in diese scheife sind einige wait.funktionen, dadurch wird 
mein Timer durcheinander und zählt nicht mehr richtig.
ich wollte also den 2ten timer (B)benutzen und die Wait funktion 
weglassen.
so in dem Art:

if(..)
{
timer-A setzen
erste teil des programms durchführen
wait()

2te teil...
waite()

3 teil
wait()
ende Programm.
}
timer-A auf 0 setzen.

[XMEN (Gast)]

> Diese Funktion rufst du vom Interrupt Handler auf. Und
> natürlich kannst du die Funktion auch von überall
> her anders aufrufen.

wie...?

[Karl heinz B. (kbucheg)]

Sagte ich doch schon:

Nimm deine jetzige Interrupt Funktion her.

// Timer B0 interrupt service routine
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B (void)
{
..
bla bla, irgendwas
..
}

Den Teil innerhalb des Handlers verschiebst du in eine
eigene Funktion:

void MeineTimerBFunktion()
{
..
bla bla, irgendwas
..
}

und rufst sie vom Handler aus auf:
#pragma vector=TIMERB0_VECTOR
__interrupt void Timer_B (void)
{
  MeineTimerBFunktion();
}

und genauso wie du sie vom Handler aus aufgerufen hast,
kannst du sie auch von anderen Programmteilen aufrufen.

Das löst dein Syntaxproblem. Ob es auch dein logisches
Problem im konkreten Programm löst, musst du selbst wissen.
Deine Beschreibung von den Timern und den Wait Sachen klingt
nicht danach.

[Christian R. (supachris)]

Sinnvoller wäre es, eine globale Variable mit Flags zu machen, in der du 
speicherst, was als nächstes passieren soll. Dann den Timer passend 
einstellen, und beim Timer-Interrupt nach dem Flag schauen, was zu tun 
ist. Abarbeiten, Timer wieder stellen und Flag für den nächsten Task 
setzen.
Zwischendurch kannste den MSP schlafen schicken.