Electrical – MSP430FR4133 timer interrupt

cmicrocontrollermsp430timer

I am trying to use the timers on the microcontroller in order to count up to 10us then add 1 to the int timer. I intend to use this in a project I am doing where I count the time between pulses from a circuit I have built. The code is as flows:

#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
      }
    }
}

The way the code should work is when the second button is pressed the interrupt will enable and the counting will begin. Then when the first button is pressed the interrupt will disable and reset the timer.

The problem I am having is that when the interrupt is enabled, it will never enter the interrupt and increase int timer. I have set up the timer using the user guide and datasheet but I am unsure if I have set it up correctly. If anyone could shed some light on this problem it would be much appreciated!

UPDATE

The code has been changed slightly to fix suggested problems but still does not work.

Best Answer

CL is right, your use of ~COV is wrong and is ruining your other settings. Here is what happens:

COV is defined in memory as:

 #define COV (1 << 1)

Inverting COV (with ~COV) does not just invert that bit, it actually inverts the entire COV field. So if you know that COV is (in binary) 0000 0000 0000 0010, then ~COV becomes 1111 1111 1111 1101. You then take this value and OR it with everything else you just carefully set up, effectively wiping out those settings.

Your TA1CCTL1 register is thus ALWAYS set to 1111 1111 1111 1101, or just ~COV.

If you want to clear COV bit, you need to do it properly:

TA1CCTL1 &= ~COV;

If you also want to clear bits A and B (for example), you could do:

TA1CCTL &= ~(COV | A | B);

Related Solutions

Electronic – Msp430 Launchpad Using Motor to Control Motor

My suggestion would be get rid of the delay function and use the built in if you are using IAR or CCS."__delay_cycles (cycles);" using the built ins, will give you more predicable results and better timing. You could probably just replace your delay for the built in, to get closer to the results you are looking for.

personally I would go about the whole thing using interrupts and timers to pull the whole thing off and use the peripherals that the msp430 has. I would suggest using the WDT as an interval timer, doing this would leave the other timer for your motor control. p1.3 is used as the wake up pin and p1.0 is the led pin.

example code

volatile int counter;
void main(void) {
    WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer
    P1DIR = 0x01;                             // P1.0 output, else input
    P1OUT =  BIT3;                            // P1.3 set, else reset
    P1REN |= BIT3;                            // P1.3 pullup
    P1IE |= BIT3;                             // P1.3 interrupt enabled
    P1IES |= BIT3;                            // P1.3 Hi/lo edge
    P1IFG &= ~BIT3;                           // P1.3 IFG cleared
    _BIS_SR(GIE);
}
// Port 1 interrupt service routine
#pragma vector=PORT1_VECTOR
__interrupt void Port_1(void)
{
    WDTCTL = WDT_MDLY_64; //enables intervals of 64mS
    IE1 |= WDTIE;  // set WDT interrupt
}
#pragma vector=WDT_VECTOR
__interrupt void watchdog_timer (void)
{
    ++counter;
    P1OUT |= BIT0;
    if (counter == 245) {  //245 x 64mS = 15.6 seconds
        P1OUT &= ~BIT0;
        WDTCTL = WDTPW + WDTHOLD; 
    }
}

Not complete nor has this code been tested, but it should turn the led on for 15 seconds every time the P1.3 button is pushed.

Electronic – Interrupt handling in microcontrollers and FSM example

The first tactic is to architect the overall firmware so that it's OK for interrupts to occur at any time. Having to turn off interrupts so that the foreground code can execute a atomic sequence should be done sparingly. There is often a architectural way around it.

However, the machine is there to serve you, not the other way around. General rules of thumb are only to keep bad programmers from writing really bad code. It is far better to understand exactly how the machine works and then architect a good way to harness those capabilities to perform the desired task.

Keep in mind that unless you really are tight on cycles or memory locations (can certainly happen), that otherwise you want to optimize for clarity and maintainability of the code. For example, if you have a 16 bit machine that updates a 32 bit counter in a clock tick interrupt, you need to make sure that when the foreground code reads the counter that the two halves of it are consistent. One way is to shut off interrupts, read the two words, and then turn interrupts back on. If interrupt latency isn't critical, then that's perfectly acceptable.

In the case where you must have low interrupt latentcy, you can, for example, read the high word, read the low word, read the high word again and repeat if it changed. This slows down the foreground code a little, but adds no interrupt latency at all. There are various little tricks. Another might be to set a flag in the interrupt routine that indicates the counter must be incremented, then do that in the main event loop in the foreground code. That works fine if the counter interrupt rate is slow enough so that the event loop will do the increment before the flag is set again.

Or, instead of a flag use a one-word counter. The foreground code keeps a separate variable that contains the last counter it has updated the system to. It does a unsigned subtract of the live counter minus the saved value to determine how many ticks at a time it has to handle. This allows the foreground code to miss up to 2^N-1 events at a time, where N is the number of bits in a native word the ALU can handle atomically.

Each method has its own set of advantages and disadvantages. There is no single right answer. Again, understand how the machine works, then you won't need rules of thumb.

Best Answer

Related Solutions

Electronic – Msp430 Launchpad Using Motor to Control Motor

Electronic – Interrupt handling in microcontrollers and FSM example

Related Topic