MSP 430G2553 Campionamento in modalità Confronta con Timer_A

Question

Amici, devo assaggiare l'ingresso, ogni 14 microsecondo in un micro secondo slot da 61 con l'ingresso timer (requisito del progetto).

Devo farlo 8 volte per fare un byte. Più come UART, ma lo sto usando per una comunicazione di un filo autobus per il mio progetto di maestri.

Ho scritto il codice come di seguito, il che dà il risultato atteso, testato eseguendo un'istruzione in un momento nel debugger.

di seguito è il codice.

/*****************************************************************************

COMPARE MODE SAMPLING:


MCLK and SCLK @8MZ

The code configures P2.1  as TA1.CCI1A input.
It samples the input at P2.1 Whenever the TA1R reaches the TA1CCR1 value.

It samples input on P2.1 every 14us once in a duration of 61 us.

It then reads 8 bits one by one to read a byte.

******************************************************************************/

#include "io430g2553.h"

#define MSP_DQ BIT5


unsigned char word=0x00;



unsigned char i=0;
unsigned char temp;

void Read(void)
{

TA1CCR0 = 0x1E8; //  61 micro secs




TA1CCR1 = 0x70; // 14 micro secs

//TA0CCTL1 = CM_2 | CCIS_0 | SCS | CAP | OUTMOD_0 | CCIE;
//Keep in mind that It should not be configured as campture mode

TA1CCTL1 |= CM_2 | CCIS_0 | SCS | OUTMOD_0 | CCIE;

TA1CTL = TASSEL_2 + MC_1 + ID_0; // Register TA0CTL -> SMCLK/1, Up mode

do{

while ((TA1CCTL0 & CCIFG) == 0 ) // wait while CCIF is set
{
}

**TA1CCTL0 &= ~CCIFG; // Clear the flag** (%1%)
//TA1CTL &= ~TAIFG; // Clear the flag
i++;
} while( i<8) ;

TA1CTL = TACLR; // Stop the Timer
TA1CCTL1 = 0x00;

}

void Configure_CCI1A(void)
{

// Configuring P2.1 as TA1.CCI1A

P2OUT &= 0x00; // Clearing P1OUT
P2DIR &= ~BIT1 ; // Configuring P1.2 as input
P2SEL |= BIT1 ; // P2.1 Timer1_A, capture: CCI1A input, compare: Out1 output
P2SEL2 &= ~BIT1 ;


}


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

BCSCTL1 = CALBC1_8MHZ;
DCOCTL = CALDCO_8MHZ;

P1OUT &= 0x00; // Clearing P1OUT
P1DIR |= BIT0 ; // Configuring P1.0 as Output

__enable_interrupt();

Configure_CCI1A();
Read();

**P1OUT ^= BIT0;** //(%2%)


while(1) {

}
}


// Timer A1 interrupt service routine
#pragma vector=TIMER1_A1_VECTOR
__interrupt void Timer1_A1 (void)
{

P1OUT ^= BIT0; // To show Read occured

word <<=1; // If x = 00000010 (binary) => x <<= 2; => x=00001000
temp=0x00;
temp=((TA1CCTL1 & SCCI)>>10);
**word = word + temp ;** //(%3%)

}

.

Ma il problema è che quando chiamo la funzione, un po 'come appare bloccato. Immagino che non venga fuori dalla ISR in pulito anche se ha completato tutta la sua esecuzione quando corro in debugger un'istruzione alla volta. Per rendere la mia domanda chiara, è così che ho testato:

Supponiamo se metto a bagnare il punto di interruzione all'espressione evidenziata (% 3%) in ISR, quindi entra nel ISR colpisce la Togglebreak 8 volte catturando i valori corretti e esce dalla funzione di lettura ordinata (e anche

while ((TA1CCTL0 & CCIFG) == 0 ) // wait while CCIF is set
{
} 

and

{

....

....

i++;

} while( i<8) ;

.

fuori dal ciclo sopra)

, per raggiungere mentre (1) espressione nella rete elettrica.

Ma invece se metto a bagnare il punto all'espressione evidenziata (% 1%) appare bloccata. O se metto il punto di interruzione di interruttore direttamente a (% 2%) nel principale ciò che mi aspetto, per completare la funzione di lettura, memorizzare il valore nella variabile di parole per raggiungere il punto di interruzione di interruttore, ma il codice appare bloccato e non colpisce il codice Togglebreak.

Non so cosa sia sbagliato, qualcuno può aiutare?

Answer 1

Il flag di interrupt viene automaticamente cancellato quando si legge TAIV o se lo cancella manualmente in tacctl1.Tuttavia, non fai nessuna di queste cose nel tuo IR, quindi l'interruzione rimane in sospeso e la CPU esegue continuamente il tuo ISR e nessun altro codice in modo che non abbia mai avuto la possibilità di uscire da Read().

La mia ipotesi è che inserendo un punto di interruzione nell'ISR il tuo ambiente di sviluppo provoca una lettura dal Taiv e cancella l'interruzione in sospeso.L'ho sperimentato prima, ma non sono sicuro di quanto sia comune che il comportamento sia così indesiderabile.