MSP430FR4133 temporizador de interrupción

0

Estoy tratando de usar los temporizadores del microcontrolador para contar hasta 10 us y luego agregar 1 al temporizador int. Tengo la intención de usar esto en un proyecto que estoy haciendo donde cuento el tiempo entre los pulsos de un circuito que he construido. El código es como flujos:

#include <msp430fr4133.h>
#include <driverlib.h>

unsigned int count = 0;
unsigned int button1 = 0;
unsigned int button2 = 0;

#pragma vector=TIMER0_A0_VECTOR
__interrupt void TimerA0_ISR0(void)
{
  count++;
}

void main(void)
{
  WDTCTL = WDTPW | WDTHOLD;               // Stop watchdog timer

    // Disable the GPIO power-on default high-impedance mode
    // to activate previously configured port settings
    PMM_unlockLPM5();  
    //Setting up buttons
    GPIO_selectInterruptEdge(GPIO_PORT_P1, GPIO_PIN3,GPIO_LOW_TO_HIGH_TRANSITION);
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN3); 
    GPIO_clearInterrupt(GPIO_PORT_P1, GPIO_PIN3);
    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN3);

    GPIO_selectInterruptEdge(GPIO_PORT_P1, GPIO_PIN4, GPIO_LOW_TO_HIGH_TRANSITION);
    GPIO_setAsInputPinWithPullUpResistor(GPIO_PORT_P1, GPIO_PIN4);
    GPIO_clearInterrupt(GPIO_PORT_P1, GPIO_PIN4);
    GPIO_enableInterrupt(GPIO_PORT_P1, GPIO_PIN4);

    //Setting up timer to count to 10us 
    TA0CTL = TACLR;
    TA0CTL = TASSEL_2|ID_0|MC_1|TACLR;   //SMCLK, divider 1, up mode, clear timer, interrupt enable, interrupt pending
    TA0CCTL0 = CM_1|CCIS_2|OUTMOD_2|CCIFG;
    TA0CCR0 = 10000;      //count to 10us = 10/1MHz/1

    while(1)
    { 
      button1 = GPIO_getInputPinValue(GPIO_PORT_P1, GPIO_PIN3);
     if(button1==0)
      {
        TA0CCTL0 &= ~ CCIE;              //disable interrupt if button 1 pressed
        timer = 0;    
      }
      button2 = GPIO_getInputPinValue(GPIO_PORT_P1, GPIO_PIN4);
      if(button2==0)
      {
        TA0CCTL0 |= CCIE;                //enable interrupt if button 2 pressed
      }
    }
}

La forma en que debería funcionar el código es cuando se presiona el segundo botón, la interrupción se habilitará y comenzará el conteo. Luego, cuando se presiona el primer botón, la interrupción deshabilitará y reiniciará el temporizador.

El problema que tengo es que cuando la interrupción está habilitada, nunca entrará en la interrupción y aumentará int timer . He configurado el temporizador utilizando la guía del usuario y la hoja de datos, pero no estoy seguro de haberlo configurado correctamente. ¡Si alguien pudiera arrojar algo de luz sobre este problema, sería muy apreciado!

ACTUALIZACIÓN

El código se ha modificado ligeramente para solucionar los problemas sugeridos pero aún no funciona.

    
pregunta Aidan Howie

2 respuestas

1

CL es correcto, su uso de ~COV es incorrecto y está arruinando sus otras configuraciones. Esto es lo que sucede:

COV se define en la memoria como:

 #define COV (1 << 1)

Invertir COV (con ~COV ) no solo invierte ese bit, en realidad invierte todo el campo COV. Entonces, si sabe que COV es (en binario) 0000 0000 0000 0010, entonces ~COV se convierte en 1111 1111 1111 1101. Luego toma este valor y O con todo lo que acaba de configurar cuidadosamente, borrando efectivamente esas configuraciones.

Por lo tanto, su registro TA1CCTL1 SIEMPRE se establece en 1111 1111 1111 1101, o simplemente ~COV .

Si desea borrar el bit COV, debe hacerlo correctamente:

TA1CCTL1 &= ~COV; 

Si también desea borrar los bits A y B (por ejemplo), podría hacer:

TA1CCTL &= ~(COV | A | B);
    
respondido por el Catsunami
0

¡Las interrupciones no fueron habilitadas correctamente!

La forma en que se solucionó esto es mediante el uso de __enable_interrupt(); . Esta función corrigió las interrupciones y les permitió trabajar.

    
respondido por el Aidan Howie

Lea otras preguntas en las etiquetas