MSP430 TimerA langsamer als erwartet?

[ToMa (Gast)]

Hallo,
ich verwende ein Launchpad MSP430F2274. Bei dem wollte ich einen Timer 
einstellen, sodass aller 5 Sekunden eine (blockierende) Funktion aus 
LPM3 heraus aufgerufen wird. Dazu eine Verständnisfrage und eine 
Seltsamkeit, mit der Bitte auf Aufklärung :)

1. Im TimerA-ISR soll erstmal einfach nur der LPM3 verlassen werden.

#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
    LPM3_EXIT;                       
}

In der main dann Folgendes:

_EINT();
  
 while(1){  
   enter_LPM3; 
   meineFunktion();
  }

Wenn während der Abarbeitung der Funktion wieder ein Timer-Interrupt 
erfolgt, läuft die Funktion dann korrekt weiter? Sollte doch eigentlich 
gewährleistet sein? Die Funktion dauert sagen wir mal max. 1 Sekunde, 
Interrupt aller 0,5 Sek, siehe nächsten Punkt. Ändert es was, wenn die 
Funktion von UART-Interrupts abhängt?

2.

  P1DIR |= LED0;                           // P1.0 output
  P1OUT |= LED0;                           // P1.0 default ON

  TACTL = TACLR;                           
  TACTL = TASSEL_1+ID_3;                   // 1 ACLK, 2 SMCLK
  TACCTL0 = OUTMOD_4 + CCIE;               // Toggle Output, CCR0 interrupt enabled
  TACCR0 = 62500;                         //theoretisch 0,5s@1MHz
  TACTL |= MC_1;                         //  UP mode

So ist der Timer initialisiert. Ich würde mit ACLK oder SMCLK bei 
jeweils 1MHz/8 und TACCR0 = 62500 ein halbsekündiges Togglen der LED 
erwarten. Die Led ist aber ca. 15s an bzw. aus. Was ist falsch?

[ToMa (Gast)]

LPM0 natürlich

[so nicht (Gast)]

ToMa schrieb:
> Was ist falsch?

Du zeigst nicht das ganze Programm. Niemand hat Lust in den Fragmenten 
zu stöbern, owohl der Fehler in der nicht gezeigten Zeile 42 steckt.

[ToMa (Gast)]

Und wer hat Lust, im gesamten Quellcode zu stöbern?  Ich bin weg. Danke 
für nichts, Forum.

[ToMa (Gast)]

Entschuldigt, ich habe überreagiert. Ich bin nur etwas frustriert, da 
ich früher das Feedback erhielt, "schreib nicht einfach deinen ganzen 
Code her, wer soll sich da durchwühlen". Und jetzt lese ich das 
Gegenteil. Sorry.
Das Timing der LEDs klappt jetzt. Wenn ich jetzt aber meine Funktion 
reinbringe, wird die main-while nciht mehr komplett abgearbeitet. (LED2 
blinkt nicht)

#include <msp430.h>
#include <stdint.h>

#define SPI_MODE0    (0+UCCKPH)         ///< CPOL = 0, CPHA = 0 
#define SPI_MODE1    (0+UCCKPL+UCCKPH)  ///< CPOL = 0, CPHA = 1 
#define SPI_MODE2    (0)                ///< CPOL = 1, CPHA = 0 
#define SPI_MODE3    (0+UCCKPL)         ///< CPOL = 1, CPHA = 1 

#define MOSI         BIT1
#define MISO         BIT2
#define SPICLK       BIT3
#define SEN_AMS      BIT4

#define SEN_AMS_SELECT   P1OUT |= BIT4;
#define SEN_AMS_UNSELECT P1OUT &= ~BIT4;

#define DUMMY_A         0xAA
#define DUMMY_0         0x00

#define AMSRESET        0xC0
#define GETTEMP         0xC1
#define GETBATT         0xC2
#define GETSTAT         0xC7
#define GETFIFO         0xE0
#define SETFIFO         0xE1

#define LED0        BIT0 //Timer A
#define LED2        BIT2 //Timer A

// ################# Variablen #################################################

unsigned char sen_data[]         = {0xAA, 0xAA, 0xAA, 0xAA};  //Interner Sensor/Spannung
unsigned char rcv_data[]         = {0xAB, 0xAB, 0xAB, 0xAB};  //Lesepuffer EEPROM
unsigned char tsm_data[]         = {0xAC, 0xAE, 0xAF, 0xAC};  //Schreibpuffer EEPROM
int fillthatarray = 0;
uint16_t addr = 0x064;

unsigned char intvl_count = 19;  // 1 sec
unsigned char i = 0;             // 10sec

// ################# Prototypen ################################################
void clk_init(void);

void spib_init(void);
unsigned char spib_write_read_byte(unsigned char);

void ams_init(void);
void ams_command_read_internal16(unsigned char);
void ams_command_writeEEPROM(uint16_t, unsigned char);
void ams_command_readEEPROM(uint16_t address, unsigned char numberOfBytes);

void timera_init(void);

// ################# MAIN ######################################################
void main(void)
{
  WDTCTL = WDTPW + WDTHOLD;                     // Stop WDT

  clk_init();
  timera_init();
 // spib_init();
 // ams_init();
  

  
  //Schreibe 4 Byte User Speicher
 // ams_command_writeEEPROM(addr, tsm_data[0]);
//  ams_command_writeEEPROM(addr+1,tsm_data[1]);
//  ams_command_writeEEPROM(addr+2,tsm_data[2]);
//  ams_command_writeEEPROM(addr+3,tsm_data[3]);
  //Lese fortlaufend User Speicher
//  ams_command_readEEPROM(addr, 4); 
//  __delay_cycles(1);
 
  _EINT();
  
  for(;;){  
    LPM0; 
    //lese Temperatur/Spannung
    ams_command_read_internal16(GETTEMP);
    ams_command_read_internal16(GETBATT);
    P1OUT ^= LED2;
    intvl_count=19;
    i++;
  }
}

// ################# Timer A #####################################################
void timera_init(void){

  P1DIR |= LED0 + LED2;                          // P1.0 output
  P1OUT &= ~LED0;
  P1OUT &= ~LED2;
  
  TACTL = TACLR;      
  TACCTL0 = CCIE;                                // Toggle Output, CCR0 interrupt enabled
  TACTL = MC_1 + TASSEL_2+ID_3;                  // 1 ACLK, 2 SMCLK
  TACCR0 = 62500;                                //62500 
  
}

// Timer A0 interrupt service routine
#pragma vector=TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
  //CCR0++;                                                                 // Add Offset to CCR0
  P1OUT ^= LED0;
  if (intvl_count ==0){ 
   LPM0_EXIT;
  }else {
    intvl_count--;
  }                        
}

// ################# Clock #####################################################
void clk_init(void){

  if (CALBC1_1MHZ==0xFF)        // If calibration constant erased
  {                      
    while(1);                               // trap CPU
  }
  DCOCTL = 0;                               // Select lowest DCOx and MODx settings
  BCSCTL1 = CALBC1_1MHZ;                   // Set DCO to 8MHz
  DCOCTL = CALDCO_1MHZ;
}

// ################# SPI ######################################################
//SPI Initialisation
void spib_init(){
  P3SEL  = MOSI + MISO + SPICLK;             // P3.2=MISO, P3.1=MOSI, P3.3=CLK
  P3DIR |= SPICLK + MOSI;                     
  P3DIR &= ~MISO;
  
  UCB0CTL0 |= UCMSB + UCMST + UCSYNC + SPI_MODE2; // MAX: SPI Mode "2"=3 (max+ams?) oder "3"=1 (nur max), MSB zuerst, 8-Bit
  UCB0CTL1 |= UCSSEL_2;                           // Clock
  UCB0BR0 |= 0x08;                                // Clock prescaler
  UCB0BR1 = 0;                                   
  UCB0CTL1 &= ~UCSWRST;                           // Beende Reset State USCI
}

//Basic RX/TX
unsigned char spib_write_read_byte(unsigned char data){
    unsigned char content;
 
    UCB0TXBUF = data;                       // Dummy write to start SPI
    while (!(IFG2 & UCB0RXIFG));            // USCI_B0 RX buffer ready?
    content = UCB0RXBUF;                     
    
    return content;
}

// ################# AMS Tag ###################################################
void ams_init(void){
 // P1OUT |= CS_AMS;                         
  P1OUT &= ~SEN_AMS;    
  P1DIR |= SEN_AMS;                           // P1.4 als Ausgang für CS_AMS
  
  SEN_AMS_SELECT;  
    __delay_cycles(200);                 
    (void)spib_write_read_byte(AMSRESET); 
  SEN_AMS_UNSELECT; 
   
  __delay_cycles(2000);
}

void ams_command_writeEEPROM(uint16_t address, unsigned char data){
   SEN_AMS_SELECT;  
    __delay_cycles(150);                 
    (void)spib_write_read_byte(address>>8);  //write command + a10-a8
    (void)spib_write_read_byte(address);  
    
    (void)spib_write_read_byte(data);  ///data     
    __delay_cycles(8000); 
  SEN_AMS_UNSELECT;  
}

void ams_command_readEEPROM(uint16_t address, unsigned char numberOfBytes){
   SEN_AMS_SELECT;  
    __delay_cycles(160);   
    (void)spib_write_read_byte(address >> 8 | 0x40);  //read command  + a10-a8
    (void)spib_write_read_byte(address);  
    
    __delay_cycles(500);
    for (int i =0; i< numberOfBytes; i++){
    rcv_data[i]  = spib_write_read_byte(DUMMY_0);
    }
  SEN_AMS_UNSELECT;  
}

void ams_command_read_internal16(unsigned char command){
  SEN_AMS_SELECT;  
    __delay_cycles(160);                 
    (void)spib_write_read_byte(command);  
    __delay_cycles(10000);      
    //while (!UCB0RXBUF);
    sen_data[fillthatarray]  = spib_write_read_byte(DUMMY_A);
    sen_data[fillthatarray+1]  = spib_write_read_byte(DUMMY_A);
    fillthatarray += 2;
  SEN_AMS_UNSELECT;  
}

[so nicht (Gast)]

ToMa schrieb:
> unsigned char intvl_count = 19;  // 1 sec
> ...

versuch 's mal mit volatile.

[wv (Gast)]

Hallo ToMa

erstmal die Frage zum Interrupt:

der Interrupt unterbricht das Hauptprogramm, springt in die ISR, 
arbeitet sie ab und fährt danach wieder an der gleichen Stelle vom 
Hauptprogramm fort. Wenn der MSP430 vorher im Schlafmodus war, kommt es 
darauf an, ob die Interruptroutine mit LPMx_EXIT verlassen wurde oder 
nicht, je nachdem schläft er also weiter im Haupprogramm oder wird 
aufgeweckt und startet bei

LPM0;

Problem in Deinem Programm ist, dass Du den Schleifenzähler im 
Hauptprogram setzt und in der ISR abwärts zählst. Volatile hilft da nur 
zum Teil, denn es kann ja auch sein, dass beim Beenden der ISR mit 
LPM0_Exit gerade ein Lesevorgang solange dauert, dass der Timer erneut 
auslöst und die Zeile

intvl_count=19;

nicht erreicht wird.

Wahrscheinlich hängt einer der beiden Lesevorgänge, das sollte man mit 
dem Debugger aber rauskriegen.

Gruß wv

[so nicht (Gast)]

Blödsinn, der int wird immer auf einmal gelesen. Entweder sieht die ISR 
ne 0 oder einen positiven Wert. Darf auch unsigned sein.

LPM0_EXIT muss aber LPM verlassen!