MSP430: Mehrere Interrupts pro Timer

[Johannes (menschenskind)]

Hallo

Ich habe 3 LEDS an den Ports des Timer B hängen und man kann für diesen 
Timer bis zu 7 Interrupts für unterschiedliche Compare-Werte auslösen 
lassen.
Jetzt hab ich TB_0.1, TB_0.2 und TB_0.3 aber ich finde in der 
MSP-Headerdatei nur diesen Eintrag:

#define TIMERB1_VECTOR       TIMER0_B1_VECTOR /* Timer0_B7 CC1-6, TB */

Wonach meine ISR so aussehen könnte:

#pragma vector=TIMERB1_VECTOR
__interrupt void TB_0.1(void){
  TBCCR1 += 100;                      
}

Aber welchen VECTOR nehme ich für die anderen beiden ISRn?

Weil TIMERB2_VECTOR und TIMERB3_VECTOR existieren nicht.

Danke
Hannes

[who (Gast)]

Um welchen Type geht es? Gib einmal die ganze Bezeichnung an.

[Mrs MSP (Gast)]

Dein Freund ist Family User Guide.

In der ISR zum TIMER_B1_VECTOR wird über das TB0IV die Interrupt-Quelle 
ermittelt. In der TIMER_B0_VECTOR ISR nur CC0.
Dazu steht bestimmt etwas in den Header-File Kommentaren.

Tipp:
Zur Auswertung kommt das __even_in_range ins Spiel.

[DirkZ (Gast)]

Mrs MSP schrieb:
> Tipp:
> Zur Auswertung kommt das __even_in_range ins Spiel.

aber nur, wenn man keinen GCC verwendet.

[Johannes (menschenskind)]

Ok, sehr schön. Hatte dann auch überlegt, dass es evtl. mit ner 
Switch-Case-Anweisung geht.
Das wäre jetzt mein Code:

#pragma vector=TIMERB1_VECTOR
__interrupt void TB(void){

  switch(__even_in_range(TBIV,3)){
    case 0x02:
      TBCCR1 += 100;                      
    case 0x04:
      TBCCR2 += 50;
    case 0x06:
      TBCCR3 += 10;
  }
}

Kann das Programm grad noch nicht testen, da der Programmer anderweitig 
im Einsatz ist, aber sieht das so korrekt aus. Die case-Werte hab ich 
der Tabelle im User Guide auf Seite 394 entnommen.
Wenn ein Interrupt kommt, werden dann diese TBCCR1..6 CCIFG entsprechend 
auf 1 gesetzt?
Ist meine Case-Abfrage dann richtig?

[Uwe (Gast)]

break?

[Johannes (menschenskind)]

Uups natürlich....hehe

Aber meine Frage gilt eher dem

switch(__even_in_range(TBIV,3)){

Weil im User Guide steht , dass für NUM (in dem Fall hab ich 3 
eingesetzt) eine Zahl ab 0 eingetragen werden muss.
Ist das dann die Anzahl der zu verarbeitenden Interrupts? Weil 0 würde 
dann ja wenig Sinn ergeben...

[Johannes (menschenskind)]

So hab's jetzt mal angeworfen, aber es blinkt leider nix :(
Die ISR wird auch nie aufgerufen (LED leuchtet nicht).
Bitte um Feedback, ob der Timer richtig initialisiert ist.
Danke

#include "io430.h"
#include "io430x54xA.h"

/*********** Setup *********************************/
#define  LED_PORT P4OUT
#define OUTPUT 0x7E //* Bit 1-6 are included in Mask

#define LED_1 ( (1*P4OUT3) | (0*P4OUT2) | (1*P4OUT1) )
#define LED_2 0x60 

/****** MAIN ***************************************/
void main( void )
{   
    WDTCTL = WDTPW + WDTHOLD; //*Stop watchdog timer to prevent time out reset
  
/** Setup Timer B **/
         TBCTL =  TBSSEL_3 +   //*Clocksource is SMCLK
      TBIE +    //*Enable Interrupt 
      TBCLR +    //*Clear Timer
      MC_2 +    //*Continuous Mode
      CNTL_1 +  //*CounterLength 0x3FF
      TBCLGRP_0 ;  //*No Grouping
  
  
  TBCCTL1 =   OUTMOD_4 +  //* Mode "Toggle Output" for TB0.1
        CCIE;
  TBCCR1 = 2000;
    
  TBCCTL2 =  OUTMOD_4 +  //* Mode "Toggle Output" for TB0.2
        CCIE;
    
  TBCCTL3 =  OUTMOD_4 +  //* Mode "Toggle Output" for TB0.3
        CCIE;
  

/** Setup Port4 as Output **/
  P4DIR = OUTPUT;
  
/** Toggle LED for Init **/  
  LED_PORT = 0x0E;
  __delay_cycles(1000000);
  LED_PORT ^= 0x0E;
  
  while(1){}   
  
}

#pragma vector=TIMERB1_VECTOR
__interrupt void TB(void){

  LED_PORT ^= 0x0E;
  __delay_cycles(1000000);

  switch(__even_in_range(TBIV,3)){
    case 0x02:
      TBCCR1 += 100;
      break;
      
    case 0x04:
      TBCCR2 += 50;
      break;
      
    case 0x06:
      TBCCR3 += 10;
      break;
  }
}

[Rufus Τ. F. (rufus)]

switch(__even_in_range(TBIV,3))

Das ist eine Optimierungsunterstützung für den Compiler, die hier wohl 
falsch genutzt wird:

The __even_in_range intrinsic provides a hint to the compiler 
when generating switch statements for interrupt vector routines.
The intrinsic is usually used as follows:
  switch (__even_in_range(x, NUM)){ ... }

The __even_in_range intrinsic returns the value x to control the
switch statement, but also tells the compiler that x must be an 
even value in the range of 0 to NUM, inclusive.

NUM ist hier 3, aber zwei von drei case-Fällen größer.

Entweder korrigieren oder ... weglassen.

switch (TBIV)

[Johannes (menschenskind)]

Ok, aber die ISR wird ja überhaupt nicht aufgerufen...
Das ist ja bis jetzt noch das Problem mit Priorität +++ :)

[DS aus W (Gast)]

Hi Johannes,

wie wäre es mit einem GIE ( _EINT() )?
Oder versteckst Du das in der Tiefe Deiner SW?

Gruss
Dietmar

[DS aus W (Gast)]

Ach ja-
zum Thema __even_in_range-
NUM soll den möglichen Wert begrenzen(timer_B also 0x0A für den TBIFG.)
Das ist zur Sicherheit, wenn irgendetwas verbogen wird.
Alles > NUM wird ignoriert.

[Rufus Τ. F. (rufus)]

DS aus W schrieb:
> Alles > NUM wird ignoriert.

Und alles, was ungerade ist.

[who (Gast)]

Johannes Hofmann schrieb:
> Die ISR wird auch nie aufgerufen (LED leuchtet nicht).

Das ist deine Debug Strategie???

Johannes Hofmann schrieb:
> __delay_cycles(1000000);

Was soll denn das in der ISR???

Da dir die noch Grundlagen fehlen, würde ich von der Try <> Error 
Variante Abstand nehmen und einen Debugger einsetzen. Der µC hat 
bestimmt das Spy By Wire Interface.

Leider gibst du den µC Typen nicht preis. Zum Verständnis habe ich darum 
ein Beispiel fürs launchpad mit dem G2255 geschrieben:

#include "io430.h"

volatile int foo = 0;

int main( void )
{
  // Stop watchdog timer to prevent time out reset
  WDTCTL = WDTPW + WDTHOLD;
  
  BCSCTL1 = CALBC1_1MHZ;
  DCOCTL = CALDCO_1MHZ;
  
  TA0CCR0 = 0xFFFF;                 // if up mode is used
  TA0CTL |= TASSEL1 | MC1 | TAIE;
  
  TA0CCR1 = 0xF000;
  TA0CCTL1 |= CCIE;
  
  TA0CCR2 = 0x0100;
  TA0CCTL2 |= CCIE;
  
  __enable_interrupt();
  
  while (1) ;

  // return 0;
}

#pragma vector=TIMER0_A1_VECTOR
__interrupt void Timer0_A1_ISR(void) {
  
  switch (__even_in_range(TA0IV,0x0A)) {
    case TA0IV_TACCR1 :
      foo = 1;
      break;
    case TA0IV_TACCR2 :
      foo = 2;
      break;
    case TA0IV_TAIFG :
      foo = 5;
      break;
    default :
      foo =  -1;
  }
}

[Johannes (menschenskind)]

Naja, mit der LED hab ich das bisher immer so gemacht. Aber ich könnte 
mir im Debugmodus natürlich die einzelnen Register auch mal anschauen.
Hab mir ja ein paar Tutorials angeschaut und Beispiele zur 
Timeransteuerung, aber eben noch keine Erfahrung, wo ich genau nach dem 
Fehler suchen könnte.

Manche benutzen bei der Wertzuweisung eines Registers manchmal den '+'- 
anstatt den '|'-Operator. Muss man dabei irgendwas beachten oder ist das 
vom Effekt her deckungsgleich?

[who (Gast)]

Johannes Hofmann schrieb:
> ich könnte
> mir im Debugmodus natürlich die einzelnen Register auch mal anschauen

Du bist soooo großzügig. >:->

Man kann aber auch Breakpoints setzen. ;-)

Schau dir zuerst die ISR an versuch dein Programm ans Laufen zu 
bekommen. Das mit den Feinheiten kommt später. Ach, aber auf keinen Fall
reg += bit1 + bit7;
    ^^
schreiben!!!

[DS aus W (Gast)]

Das Schlimme ist, 0b0001 + 0b0010 = 0b0011
und TI macht das in ihren Beispielen.
Der Effekt ist tatsächlich gleich.
Aber das ist Murks (schlechter Stil).
Ein ODER ist ein ODER - immer.
Ein + ist eine arithmetische Operation.
Gewöhne Dir bitte den Quatsch von TI nicht an.

Dann wäre es nett, wie schon geschrieben, wenn Du
Controllertyp und Umgebung nennen würdest ;-)
Meinen Hinweis von oben findest Du im Beispiel von who:
__enable_interrupt();

Schönen Abend noch!

[who (Gast)]

Solange nur mit Flags gerechnet wird und eine Zuweisung erfolgt kommt 
das gleiche raus. Aber bei Konstanten aus 2 oder mehr Bit oder bei 
Einbeziehung des left value mit bereits gesetzten Bits f.... du dich ins 
Knie.

Also nicht nur schlechter Stil, sondern oft falsch !

[Johannes (menschenskind)]

Es ist ein MSP430F5438A.
Arbeite mit der IAR Workbench.

Die ganzen Register für die Konfiguration sind doch von vorneherein alle 
mit 0 initialisiert. Und nur wenn ich ne andere Konfiguration als die 
Standardeinstellungen haben möchte, muss ich die entsprechenden Bits auf 
1 setzen. Ist doch so?

[Johannes (menschenskind)]

Also im TBIV-Register wechseln die entsprechenden Interruptflags auch 
ganz artig, aber es kommen auch Kombinationen vor, die gar nicht auf 
meine 3 Interruptvektoren zutreffen.

[Johannes (menschenskind)]

Also die ISR funktioniert, aber ich sehe leider nichts an den LEDS
Das OUT-Signal müsste ja nun an den 3 Pins anliegen und somit die LEDs 
schalten.
Habe auch nichts im User Guide gefunden, dass man da für die PWM noch 
was konfigurieren müsste.
Der Timer zähl bis 0xFFFF und eine Manipulation des TBR-Wertes bringt 
auch keinen Erfolg.
Langsam wird's unschön... :(

#include "io430.h"
#include "io430x54xA.h"

/*********** Setup *********************************/
#define  LED_PORT P4OUT
#define OUTPUT 0x7E //* Bit 1-6 are included in Mask

#define LED_1 ( (1*P4OUT3) | (0*P4OUT2) | (1*P4OUT1) )
#define LED_2 0x60 //* ( (0<<P4OUT6) | (1<<P4OUT5) | (1<<P4OUT4) )

#define ON 1
#define OFF 0
#define DELAY_1 10000

/****** MAIN ***************************************/
void main( void )
{   
    WDTCTL = WDTPW | WDTHOLD; //*Stop watchdog timer to prevent time out reset
  
/** Setup Timer B **/
  TBCTL =  TBSSEL_2 |     //*Clocksource is SMCLK
        TBIE |    //*Enable Interrupt 
        TBCLR |    //*Clear Timer
        MC_2 |    //*Continuous Mode
        CNTL_0;    //*CounterLength 0xFFF  
    
  TBCCTL1 =   OUTMOD_4 |  //* Mode "Toggle Output" for TB0.1
        CCIE;    //* Enable Interrupt for Register
  TBCCR1 =   2000;    
    
  TBCCTL2 =  OUTMOD_4 |  //* Mode "Toggle Output" for TB0.2
        CCIE;
    
  TBCCTL3 =  OUTMOD_4 |  //* Mode "Toggle Output" for TB0.3
        CCIE;  

/** Setup Port4 as Output **/
  P4DIR = OUTPUT;
  
/** Toggle LED for Init **/  
  LED_PORT = 0x0E;
  __delay_cycles(DELAY_1);
  LED_PORT ^= 0x0E;
    __delay_cycles(DELAY_1);
  
  __enable_interrupt();  //* Enable Interrupts
  
  while(1);
  
}

#pragma vector=TIMERB1_VECTOR
__interrupt void TB(void){

  //switch(__even_in_range(TBIV,3)){
  switch(TBIV){
    case 0x02:
      TBCCR1 += 1000;
      break;
      
    case 0x04:
      TBCCR2 += 100;
      break;
      
    case 0x06:
      TBCCR3 += 50;
      break;
    default:
      break;
  }
}

[DirkZ (Gast)]

Johannes Hofmann schrieb:
> Es ist ein MSP430F5438A.
> Arbeite mit der IAR Workbench.

Nur der MSP430F5438A oder das MSP-EXP430F5438?

Schau mal hier: 
http://320volt.com/wp-content/uploads/2010/10/msp430x23x0_tb_07.c.html

//   As coded with TBCLK ~1.2MHz DCO, toggle rates are:
//   P4.0 = TBCCR0 = 1200000/(2*200) = 3000Hz
//   P4.1 = TBCCR1 = 1200000/(2*400) = 1500Hz
//   P4.2 = TBCCR2 = 1200000/(2*600) = 1000Hz

toggle - an/aus: leuchtet die LED bei 3khz?


Oder lieber PWM?
http://320volt.com/wp-content/uploads/2010/10/msp430x23x0_tb_10.c.html

[who (Gast)]

Johannes Hofmann schrieb:
> Der Timer zähl bis 0xFFFF und eine Manipulation des TBR-Wertes bringt
> auch keinen Erfolg

Welchen Erfolg erwartest du? Wenn es Änderungen der Ausgänge an P4 sein 
sollen, musst du sie auch beeinflussen. Entweder setzt oder löscht du 
die Ausgänge selbst, oder du nutzt die alternativen Pin-Funktionen. Und 
woher weiss der µC was du willst? Natürlich, ein Konfigurationsregister: 
PxSEL.

Jetzt geht es im Family User Guide weiter.

[Johannes (menschenskind)]

Hm, und warum ist dann nicht ein klitzekleiner Hinweis im User Guide 
aufgeführt, dass man das P4SEL noch manipulieren muss.
Jetzt funktioniert es.

Gleich noch ne Frage:
Kann man aus irgeneinem Register den Maximalwert des Timers abrufen? Aus 
TB0R kriegt man den aktuellen Zählwert.
Mit CNTL_0 bis CNTL_3 kann man den Wert ja nur einstellen.

[Dennis (Gast)]

Das ist im Datenblatt zum Controller aufgeführt.

Und was heißt der Maximalwert? Bei 16Bit: 65535

[Johannes (menschenskind)]

Naja, wenn ich den Wert per Registereinstellung ändere, dann muss sich 
der Controller den Wert ja irgendwo herholen.
Und das würd ich auch gern. Aus Gründen der Übersichtlichkeit des Codes.

[Dennis (Gast)]

Du schreibst den doch in die CCR-Register

[who (Gast)]

Johannes Hofmann schrieb:
> und warum ist dann nicht ein klitzekleiner Hinweis im User Guide
> aufgeführt, dass man das P4SEL noch manipulieren muss.

Bei einem Blick auf das Bauteilsymbol fällt dir sicherlich auf, dass 
verschiedene Pins mehrere Funktionen haben können. Kann der µC raten was 
du möchtest? Warum muss man überhaupt programmieren? ;-)

Im Kapitel 12.2.6 finde ich einen "klitzekleinen Hinweis".

Aber lesen ist schwer, Englisch auch noch, aber ... im Datenblatt auf 
Seite 72 gibt 's soagar ein Bildchen vom Port. ;-)

Keine Ausreden mehr: Lesen, Programmieren, Debuggen und Freuen!