Counting impulses

You are right! I misunderstood CCR mechanism. I want to implement it in a first way (with two timers).

But, I have additional problem. I am using MSP430F5438. As I understood it has 3 timers: A0, A1 and B. Right? But I am already using timer B for generating PWM. And timer A1 is occupied by operating system. And on A0 I implemented time frame of 9.1 ms (and it works OK). So, I do not have enough timers. I need additional one on which I should connect external input.

I like more your first approach. Because I need to count impulses in defined time frame. (I have high impulse frequency 500 kHz, and high clock frequency 8 MHz)

How can I configure timer to react on external impulse source? Is it CCIS?

Any suggestions?

Depending on the required timings, you might shrink PWM, OS and one of the counting timers into one.

I don't know about the OS you're using. On my own 'OS', I set up TimerA1 (the smallest one)  counting continuously with 1MHz clock. For the 1ms cyclic interrupt, I use TA1CCR0 in compare mode and increment it by 1000 each time the interrupt is fired. This way, I get it called each ms. Even if the ISR is called wit a slight delay (due to another ISR being active at the exact moment), the next one will be triggered properly (there is some fallback machanism ensuring that it won't stall for 65 seconds if IRQs are disabled for longer than 1 ms). TA1CCR1 is used for the µs delay function and if I need any other delay, I set upt TA1CCR2 for it (e.g. setting TA1CCR2 to TAR+9100 for a 9.1ms delay). If you know what the OS is doing with TA1, you might fuse it with your delay. And even as the clock source for the counter. Or you use TB for the PWM and set up one PWM channel (there are up to 6 on TB) as gate impulse for the counting timer.

If everything gets tight, you can (ab)use the watchdog timer as an additional fourth timer. It has no external clock source nor output pins or CCR registers, but for a delay (what else is the WDT mechanism) it is good enough. Just disable the WDT interrupt and use it as a normal timer that issues an IRQ on overflow.

Let's ignore my interrupt solution for a moment.. Also, let's ignore that I need additional timer. Let's ignore time frame.

I just want to count impulses on P1.1. How can I configure timer to react on external impulse source from P1.1?

On the 5438, P1.1 is connected to TA0.0. There's no way to 'count' with this pin. You can either trigger a port interrupt using the port control logic, or trigger a capture interrupt using TA0CCR0. That's all. Bot can only detect the presence of a line transition, but not count at all. If you're clocking with 8MHz, you'll have 16 clock cycles per pulse for reacting to the event in your ISR. Since entering and leaving an ISR takes a fixed time of 11 cycles and between two ISRs, at least one normal CPU instruction is done (not to count the time to wake up from any LPM if you use this), you simply have no time for counting 500KHz pulses in an ISR.

You can shortcut P1.1 with P1.0. This will clock TA0 with your signal, turning it into a pulse counter that can count up to 18MHz pulses. You can use TA0CCRx in compare mode to trigger an interrupt after a certain number of pulses and compare the moment of the interrupt with your timebase (e.g. TimerA1) to get the average frequency.

Some newer MSPs support portmapping, so you can assign any port or module function to any physical pin (or even several at the same time to the same pin, effectively connecting them internally), but while the documentation of this feature has been added to the 54xx family user guide, the memory mapping seems to be not available in the 5438 (and isn' t mentioned in the device datasheet too). So if your signal is on P1.1, the mentioned shortcut to P1.0 is the only way. (you must setup the port pin properly and select TASSEL_0 as TA0 clock source)

Thank you, thank you, thank you...

I did same thing:

First I try to count impulses with "capture mode". It did not work.

Second, I used interrupt logic on portP1.1. It worked up to 300 KHz. I fixed it with higher clock 20 MHz, or with 100 kHz impulses. Both solutions works fine. But my project manager and software architect are not satisfied. They sad it is not in a spirit of embedded programming.

Third, I will try to ask HW developement to switch impulses from P1.1 to P1.0. In that case Timer will be sourced from TA0CLK, and it will count impulses. But I am not sure if it is possible in this phase of project.

That is good idea... I will route my signal to pin P1.0. So, it will behave as "external clock source". I will count  clocks which will be equal to impulse count.  It will be much more efficient.( In my previous solution, 90% of time - ISR is active. )When I implement your idea, I will post code here...

HW department is 600 km from my location. So, I will need to do some soldering... :)

Hi,

I am working on a similar problem. How you  solved the problem finally. Can you post the code?

There were 2 solutions.

First solution (interrupt):

Create interrupt service routine which will increment some variable each time input goes from high to low (or low-to-high). This is quite easy to implement, but results are not so good. If impulses are arriving slowly, it will work more or less OK. But if impulses are arriving to fast (faster than ISR can process single impulse) , some of impulses will be skipped, and you will count less impulses than arrived. This solution was not accepted...

Second solution(requested hardware modification on my board):

You must connect impulses to specific pin. To be more exact to TA0.0 (P1.0), pin no 17 on MSP430F5438. In this configuration impulses will act like external clock (TA1CTL = TASSEL_0), which will be counted in TA0R. In my implementation, I am using 2 timers. Timer 0 for counting impulses, and timer 1 for generating time frame of 4.551 milisecond in which I am counting impulses.

MAIN:

    /*******************************************************************/
    /* TIMER 1 initialization - timer should be stopped during setup   */
    /* TIMER 1 will count for  time frame (4,551 ms)                   */
    /* REGISTER 2 will be used for counting time frame                 */
    /*******************************************************************/
    TA1CTL    = ( TASSEL_2 | ID_0 | MC_0 |   TACLR | TAIE);                     /* SMCLK, devider = 1, stop mode, clear, enable interuupts  */
    TA1CTL   &=~(TAIFG);                                                        /* clear pending interrupts */

    TA1CCTL2 |= ( CM_0 );                                                       /* register 2: no capture */
    TA1CCTL2 &=~( CAP | CCIE | CCIFG);                                          /* will compare impulses, interupt disabled, clear pending interrupts */

    TA1CTL   |= ( TACLR | MC_2 );                                               /* clear timer and start continious mode counting */
    TA1CCTL2 &=~(CCIFG);                                                        /* clear pending interrupts */
    TA1CCTL2 |= (CCIE);                                                         /* enable interrupts */
    TA1CCR2   = IMPULSES_TIME_FRAME;                                            /* setup time frame */




    /*******************************************************************/
    /* TIMER 0 initialization - timer should be stopped during setup   */
    /* TIMER 0 will count external source impulses                     */
    /*******************************************************************/
    TA0CTL    = ( TASSEL_0 | ID_0 | MC_0 );                                     /* external clock, devider = 1, stop mode  */
    TA0CTL   |= ( TACLR );                                                      /* clear  */
    TA0CTL   |= ( MC_2);                                                        /* start counting impulses */





    /***************************************************************/
    /* WAIT BLOCK                                                  */
    /***************************************************************/
    finished = 0;
    while (finished == 0)   

   {

   }

          do something with iImpulses1

ISR:

#pragma vector=TIMER1_A1_VECTOR
static __interrupt void FREQUENCY_IMPULSES_1_ISR(void)
{


  if(TA1CCTL2 & CCIFG)                                                          /* only if interrupt is related to               */
  {                                                                             /* compare register 2 (which contains time frame)*/
    iImpulses1 = TA0R;

    finished = 1;                                                               /* signal that counting is finished - unblock waiting */

    /* stop timers */
    TA0CTL   |= (MC_0);                                                         /* stop counting on Timer A0 */
    TA1CTL   |= (MC_0);                                                         /* stop counting on Timer A1 */
    TA1CCTL2 |= (CM_0);

    /* clear interrupts */
    TA0CTL   &=~( TAIE | TAIFG);                                                /* A0: interupt disabled, clear pending interrupts */
    TA1CTL   &=~( TAIE | TAIFG);                                                /* A1: interupt disabled, clear pending interrupts */
    TA1CCTL2 &=~( CCIE | CCIFG);                                                /* A0, R2: interupt disabled, clear pending interrupts */
  }


}

 If you still have questions, feel free to ask...

This code can be optimized further for higher precision and less CPU usage:

Timer A0 is set up for counting pulses.
TA0CCR0 is set up in capture mode, raising edge, interrupt enabled.
TA0CCR1 is set up to capture mode, falling edge, no interrupt.

TimerA1 is set up for the delay, but instead of causing an interrupt, it is set up in a way that it will output the time window on an output pin (using TA1CCRx with toggle mode).

Then the output of TA1CCRx is routed externally to the TA0.0 and TA0.1 pins.

What happens?

When TA1.x goes low, the current count of TA0 is captured into TA0CCR1 register.
When TA1.x goes high, the current count of TA0 is captured into TA0CCR0 register and the ISR for TA0CCR0 is called.
There you can easily determine the number of pulses while TA1.x was low by subtracting the content of TA0CCR1 from TA0CCR0.

It is 100% accurate (because the values are captured by the hardware pulse and not by the ISR with all its latency). And you have all the time while TA1.x is high (depends on your TimerA1 setup) to react, even if other ISRs are currently executed or the chip is in LPM and requires some time to wake up.
And the code required to cyclic calculate the number of pulses is a one-liner.

Thanks to both of you. I am going to start work soon. Will post my experience as soon as get it done.

My solution have "newbe approach"... It is not perfect, it is not optimized, it is not nice, it is not fast, it is not easy to read, but it works...

@ Jens-Michael Gross: Excelent idea. I need to read it twice to understand... But, when I finally understood... Your solution is simply briliant!

You are Guru... For how ong are you working with microcontrollers?

Later , I implemented correction function for interrupt latency.  Do you have crystal ball?

On MSP430F5438 the input is connected to TA0.0 (P1.0), pin no 17. For MSP430F412 should it be P1.0 ( pin 53) or P1.1( pin 52 ).

I have another question,

If I want to preset a counter to certain value  and then count input pulses and when it reached to preset value increase a certain variable and again start counting pulses from zero.  how can I implement this.

Sorry if this is too basic, I am also a newbe.

flek said:

I need to read it twice to understand

flek said:

You are Guru... For how ong are you working with microcontrollers?

flek said:

Do you have crystal ball?

Samina Asif said:

If I want to preset a counter to certain value  and then count input pulses and when it reached to preset value increase a certain variable and again start counting pulses from zero.  how can I implement this.

This can be also done using one of the timers. Again, the pulses are used to 'clock' the timer (e.g. using the TACLK pin for TimerA).

You can

1) preset the Timer by assigning any value you want to TAR.
2) use the TACCRx modules to generate an interrupt when TAR is counted to a preset value
3) the ISR can increment your variable (it must be declared volatile, as it is altered inside an ISR)

I do not recomment, however, resetting the timer to 0. Between the trigger pulse and the execution of the ISR, more pulses might have arrived which you'd reset too. It's better to let the timer just count on, increase the CCR trigger value instead and (if required at all) calculate a difference between TAR and the last trigger value rather than using its value zero-based.

Basically it is not different from the timing function I prefer: Let TimerA run in cont mode (but in my case clocked by a 1MHz internal clock), set TACCR0 to 1000, so after 1ms, an interrupt is triggered. In the ISR, I increase TACCR0 by 1000, so the next interrupt comes at TAR=2000, without losing any tick and no matter how long it took before my ISR was executed), and then increment a global variable, so i have a ms counter variable. (and every 1000th call of the ISR, I also increment a seconda counter variable).

I am using MSP430F4132 for pulse count but I have to implement two functions.

1. Count pulses for some specific interval lets say 5ms, the pulse frequency is not more than 2Khz.The time interval may be changed through external interrupt.

2. increment certain variable when a certain no. of pulses has arrived lets say 1000. The preset value may be changed through external interuppt. (I case of using timer the interrupt to increment the variable is linked with time as you said I msec , but I want it to relate it with pulse count  1000/500 pulses).

How can I do it efficiently.

Is it OK if I use the approach of two timers used by flek along with your suggestions for
task 1 connecting input to pin 46 (P1.7/TA0CLK CAOUT/CAI).

And for second task use the timer A1 raising edge interrupt to increase a counter which is
incremented with every interrupt and every time counter reached 1000 another variable say 'X'is increased
and counter is set 0.

like

********************************
#pragma vector=TIMER0-A0_VECTOR
__interrupt void Timer_A (void)
{
  count++;
  if (count == 1000)                      

  {
    count = 0;
    X++;

  }
}

***********************************************

Can I use timer A1 raising edge interrupt in two funcions

Samina Asif said:

Can I use timer A1 raising edge interrupt in two funcions

Actually, TAR overflow shares the same interrupt vector (and therefore ISR) with the CCRx interrupts. Only CCR0 has its own vector.
So you'll need to check what caused the interrupt anyway. It is done by reading the TAIV register. It will read '2' if it is CCR1 interrupt, '4' on CCR2 and '16' or so for the TA Overflow. It is 'necessary' to read the TAIV register, so the interrupt for this event is cleared (writing to TAIV will clear all interrupts IIRC).

I have another question, is it possible to change the time frame of counting externally. if yes then how.

Three weeks passed and still no answer?

Okay, what is the easiest way to stop the counting? You can use simple digital (TTL) logic:
Gate the pulses with an AND gate, then an external gating signal can enable/disable the routing of the counted signal to the MSP and also raise an interrupt ( on port 1 or 2) to signal the end of the measurement period.
Alternatively, you can set one of the CCR units to capture mode, so it will freeze the current counter value when an external signal arrives. It can also raise an interrupt so you can read the value, calculate the difference to the last interrupt etc.

How to do it best depends on the exact requirements and available signals.

Hi,

Thanks for reply. Actually what I need is to know the way if there is any that an external programmer can change certain parameters, like

Initially I set time to 5 sec and another counter to 1000 pulses. Now if some user after some time want to change time to 10 sec or the second counter to 500, how to do it

Regards

A copy from my answer in our separate conversation (so other can read it too):

Jens-Michael Gross said:

This code can be optimized further for higher precision and less CPU usage:

Timer A0 is set up for counting pulses.
TA0CCR0 is set up in capture mode, raising edge, interrupt enabled.
TA0CCR1 is set up to capture mode, falling edge, no interrupt.

TimerA1 is set up for the delay, but instead of causing an interrupt, it is set up in a way that it will output the time window on an output pin (using TA1CCRx with toggle mode).

Then the output of TA1CCRx is routed externally to the TA0.0 and TA0.1 pins.

What happens?

When TA1.x goes low, the current count of TA0 is captured into TA0CCR1 register.
When TA1.x goes high, the current count of TA0 is captured into TA0CCR0 register and the ISR for TA0CCR0 is called.
There you can easily determine the number of pulses while TA1.x was low by subtracting the content of TA0CCR1 from TA0CCR0.

 

I wanted to implement your idea(above mentioned one)  using CC430F6137 timer.What all the thing I need to consider or modify in order to achieve in my board.

Jens-Michael Gross said:

TimerA1 is set up for the delay, but instead of causing an interrupt, it is set up in a way that it will output the time window on an output pin (using TA1CCRx with toggle mode).

Then the output of TA1CCRx is routed externally to the TA0.0 and TA0.1 pins.

But I am bit confusion about TA0.0 and TA0.1 pins, what are these pin? and how can I route TA1CCRx output to them(sorry for asking this I am newbie still struggling to get thing)s ?.

MY actual plan is to count the input pulses(external) by using the timer as counter but before using the external pulses I wanted to count internal pulses by giving them as external pulses(coz i dont have any external source right now)i.e.BY taking  the input from input pins with or without delay.

Please help me to achieve this.

Thanks in advance,

Jagasedara

Jens-Michael Gross said:

To do what you want, you need two timers.

One is set for generating the time delay. Set it as PWM output with the desired time period/frequency.

The other one is set to count on an external clock instead of SMCLK or so. This external clock is your impulse you want to count. Each impulse inceremnts the second timer.

Now set up one of the CCRx registers of the second timer for capture mode. And connect the timer output of the first timer with the port pin assigned to this register (as INPUT).

The PWM signal generated by timer 1 will 'freeze' the current value of timer 2 in the CCRx register (and cause an interrupt). timer2 will continue counting the clock pulses it gets from your external source until the next PWM period has expired. Then it will again capture the current value of timer 2 and trigger your ISR. If you build the diffeerence between the values of two consecutive capture interrupts, you'll get the number of pulses that passed in between.

 

Hi jens,

I tried to implement your post(2nd post in this thread) and wrote below prog.

#include"cc439f6137.h"

void main()

{
  WDTCTL = WDTPW + WDTHOLD;

  PMAPPWD = 0x02D52;
  P2MAP1 = PM_TA1CCR1A ;
   PMAPPWD = 0;   
  
   P2SEL |= 0x01;
   P2DIR |= 0x01;
 
 
  TA0CTL = TASSEL_2 + MC_1 + TACLR ;

  TA1CTL = TASSEL_0 + MC_1 + TACLR ;

  TA1CCTL1 = CAP + CM_1;
 
  TA1CCR1 += T0AR ;
 
 
  __bis_SR_register(LPM0_bits + GIE);  // Enter LPM0, enable interrupts
  __no_operation();                  // For debugger

}

#pragma vector=TIMER1_A1_VECTOR
__interrupt void TIMER1_A1_ISR(void)
{
    if(TA1CTL & TAIFG)
    {
     count += TA1R;

   
    }
}

Jens-Michael Gross said:

Now set up one of the CCRx registers of the second timer for capture mode. And connect the timer output of the first timer with the port pin assigned to this register (as INPUT).

but to connect the timer output of the first timer with the port pin assigned to CCRX register..how i need to achive i dont know ..i wrote something pls check..

corrct it..

Jens-Michael Gross said:

The PWM signal generated by timer 1 will 'freeze' the current value of timer 2 in the CCRx register (and cause an interrupt). timer2 will continue counting the clock pulses it gets from your external source until the next PWM period has expired. Then it will again capture the current value of timer 2 and trigger your ISR. If you build the diffeerence between the values of two consecutive capture interrupts, you'll get the number of pulses that passed in between.

I didnt get that this part and "build the difference between rhe values of two capture interrupts " i could not understand this also.

Please try to help me..

thanks in advance,

jagas

JAGAS EDARA said:

I didnt get that this part and "build the difference between rhe values of two capture interrupts " i could not understand this also.

The two capture/compare registers are configured to 'capture' the current timer count on the rising or falling edge of the Timer1 square wave signal (which mus tbe routed externally to the two CCR input pins).
So on the first edge one CCR unit captures the tiemr count, and the second edge, the other one captures teh tiemr count. The difference between the two captured coutns is the number of pulses that happened between the two Timer1 signal edges.
Also, Timer1 can be set up to trigger an interrupt at the second edge, so you can write an ISR that does the math each time a cycle is finished.

The software then is only initializing the timers and the ISR that fetches the two captured counts and calculates the frequency by the number of pulses. And shows it somehow.
Most of the time the CPU is doing nothing and can remain in low power mode. Except for the timebase clock used to drive Timer1.

JAGAS EDARA said:

to connect the timer output of the first timer with the port pin assigned to CCRX register..how i need to achive i dont know

JAGAS EDARA said:

  TA0CTL = TASSEL_2 + MC_1 + TACLR ;
  TA1CTL = TASSEL_0 + MC_1 + TACLR ;
  TA1CCTL1 = CAP + CM_1
  TA1CCR1 += T0AR ;

No. TA1So you're using TA0 for the timebase and TA! for capturing. Fine.

However, you'll need to set up TA0CCR0 for the timing interval, if you don't want a full 65536 timer counts between two measurements. Then you need to set up TA0CCTL1 in compare mode, one of the double-action outmodes. Let's assume reset/set mode. Then set TA0CCR1 to the value that defines the 'sample time'. TA0.1 is set as output for the resulting signal.

For TA1, you need to set up TA1CCTL0 and TA1CCTL1, both for capture. Both input pins need to be configured for module input. But TA1CCTL0 is for rising edge and TA1CCTL1 for falling edge.  TA1CCTL1 captures TA1R when TA0R counts to 0 (reset, fallign edge of TA0.1 output), TA1CCTL1 captures TA1R when TA0R counts to TA0CCR1 value (set, rising edge).
Also, you can enable the CCIE bit for TA1CCTL0, so you'll get an interrupt triggered on the falling edge that ends the sample time.

When the interrupt is triggered, TA1CCR1 contains the TA1R value at the beginning of the sampling time, and TA1CCR= the value at its end. The difference is the number of pulses during the sampling time.

The time between TA0CCR1 and TA1CCR0 (in up mode) or 65536 (in cont mode) must be large enough to allow the ISR to be entered and the difference been built, or else teh previous results will be overwritten by the begiinning of the next sampling time cycle.

Can you post the code that worked for you ....... i am working on a similar project using ez430-rf2500 kit and i'm in a hurry. i need to make it work by tomorrow and posting your code would be really helpful..... Thanks in advance

It’s rather unlikely that three years later, the one you want the code from is still around. Let alone answering within a few hours.
If you are really in a hurry, and are unable to dig out already posted code for this problem, then you shouldn’t waste time calling for it but rather try on your own.

@Jens-Michael Gross
I want to see your code is not? I don't understand.

I did not write (nor need) any code. I was just giving hints to those who did.

So when you wrote “the code that worked for you”, I thought it was addressed to Jagas Edara, who hasn’t been here for almost one and a half years now (and required help for this topic three years ago).