Pre-release CC26XX / CC13XX PWM and GPTimer driver

Hi Pixbroker,

Not sure why it was not included in the 2.16/18 release, it should have been.
Good news it that it is included in the 2.20 version and you should be able to use it directly in your BLE 2.2.0 release which uses TI RTOS 2.18.

I have attached an archive with the drivers/files you might need from 2.20 for your convience.

Regards,
Svend

pwm_2_20.zip

Pixbroker,

Between v2.18 and v2.20, both drivers and examples should be OK to use with both.
Examples for both PWM and the ADC are found at the following path:

<ti_rtos_2_20_path>examples\IAR\CC2650_LAUNCHXL

Regards,
Svend

Svend,

I can't figure out how to use the prescaler in edge time mode either. I see that the GPTimerCC26XX_getTimerValue() function returns the top 24 bits (the return value is ANDed with 0xFFFFFF) but I don't see how you set the prescaler before using the timer? When setting up/opening the timer, the GPTimerCC26XX_Params declaration doesn't include a field to set the prescaler value, and I can't see where it might be accomplished?

A short example would be really helpful here.

Thanks, as always,

-Ben

Hi Ben,

I do not think that TI implemented a "setprescaler" API function for the GP timer.

So you need to add it for yourself.

I've modififed for my project the GPTimerCC26XX.h and GPTimerCC26XX.c as follows:

Add to GPTimerCC26XX.h:

/*!
 *  @brief
 *  Definitions for controlling prescale value for timer.
 */
typedef enum GPTimerCC26XX_Prescale
{
    GPTimerCC26XX_PRESCALE_1    = 0,
    GPTimerCC26XX_PRESCALE_2    = 1,
    GPTimerCC26XX_PRESCALE_3    = 2,
    GPTimerCC26XX_PRESCALE_4    = 3,
    GPTimerCC26XX_PRESCALE_5,
    GPTimerCC26XX_PRESCALE_6,
    GPTimerCC26XX_PRESCALE_7,
    GPTimerCC26XX_PRESCALE_8,
    GPTimerCC26XX_PRESCALE_9,
    GPTimerCC26XX_PRESCALE_10,
    /*..*/
    GPTimerCC26XX_PRESCALE_100  = 99,
    GPTimerCC26XX_PRESCALE_101  = 100,
    GPTimerCC26XX_PRESCALE_102  = 101,
    GPTimerCC26XX_PRESCALE_103  = 102,
    GPTimerCC26XX_PRESCALE_104  = 103,
    GPTimerCC26XX_PRESCALE_105  = 104,
    /*..*/
    GPTimerCC26XX_PRESCALE_240  = 239,
    /*..*/
    GPTimerCC26XX_PRESCALE_255  = 254,
    GPTimerCC26XX_PRESCALE_256  = 255,
} GPTimerCC26XX_Prescale;

//.....

/*!
 *  @brief  Function to set the prescale of the GPTimer
 *
 *  @pre    GPTimerCC26XX_open() has to be called first successfully
 *
 *  @param  handle      A GPTimerCC26XX handle returned from GPTimerCC26XX_open
 *  @param  prescale    The prescales that should be set
 *
 *  @sa     GPTimerCC26XX_open()
 */
extern void GPTimerCC26XX_setPrescale(GPTimerCC26XX_Handle handle, GPTimerCC26XX_Prescale prescale);

and to GPTimerCC26XX.c:

/*!
 *  @brief  Function to set prescale for the GPTimer
 */
void GPTimerCC26XX_setPrescale(GPTimerCC26XX_Handle handle, GPTimerCC26XX_Prescale prescale)
{
    GPTimerCC26XX_HWAttrs const *hwAttrs = handle->hwAttrs;

    /* Disable interrupts during RMW operation */
    uint32_t key = Hwi_disable();

    if (GPT_LUT[handle->timerPart].map == TIMER_A)
    {
      uint32_t tapr = HWREG(hwAttrs->baseAddr + GPT_O_TAPR);
      /* Clear old setting */
      tapr &= ~(GPT_TAPR_TAPSR_M);
      /* Apply new setting */
      HWREG(hwAttrs->baseAddr + GPT_O_TAPR) = tapr | (prescale);
    }
    else
    {
      uint32_t tbpr = HWREG(hwAttrs->baseAddr + GPT_O_TBPR);
      /* Clear old setting */
      tbpr &= ~(GPT_TBPR_TBPSR_M);
      /* Apply new setting */
      HWREG(hwAttrs->baseAddr + GPT_O_TBPR) = tbpr | (prescale);
    }

    /* Restore HW interrupts */
    Hwi_restore(key);
}

Example:

  GPTimerCC26XX_PinMux pinMux;
  PIN_Status pinStatus;

  /*
   * Setup GPT parameters
   */
  GPTimerCC26XX_Params_init(&timerParams);
  timerParams.width             = GPT_CONFIG_16BIT;
  timerParams.mode              = GPT_MODE_EDGE_TIME_UP;
  timerParams.debugStallMode    = GPTimerCC26XX_DEBUG_STALL_OFF;
  hIrDataTimer = GPTimerCC26XX_open(CC2650_GPTIMER0B, &timerParams);

  /*
   * Setup GPT & PIN
   */
  GPTimerCC26XX_setCaptureEdge(hIrDataTimer, GPTimerCC26XX_BOTH_EDGES);
  GPTimerCC26XX_setPrescale(hIrDataTimer, GPTimerCC26XX_PRESCALE_240);
  pinMux = GPTimerCC26XX_getPinMux(hIrDataTimer);
  pinStatus = PINCC26XX_setMux(irPinHandle, IOID_12, pinMux);

Its working fine with TI-RTOS 2.16. I didn't try it on 2.20.

You would need to read the reference manual to get it working properly.

I hope it would help.

Regards,

Milorad

Hi Benjamin,

When I made the driver I did not add configuration of the prescaler, therefore it is set to 1x prescaling (no prescaling) by default.

To simplify the driver (=smaller footprint) it only supports the timer modes where the prescaler is used as a linear extension of the timer ( bits [23:16] ) and not a true prescaler (which would use the prescaler as bits [7:0]. These modes are described in the TAPR register:

Timer A Pre-scale
This register allows software to extend the range of the timers when they are used individually.
When in one-shot or periodic down count modes, this register acts as a true prescaler for the timer counter.
When acting as a true prescaler, the prescaler counts down to 0 before the value in TAR and TAV registers are incremented.
In all other individual/split modes, this register is a linear extension of the upper range of the timer counter, holding bits 23:16 in the 16-bit modes of the 16/32-bit GPT.

With the default settings you should be able to measure edge time up to 2^24 / 48MHz = 349ms.

I am actually not sure how it would behave if you were to configure the prescaler when it is used as a linear extension of the timer but my guess is that the prescaler value configured through TAPR.TAPSR will simply be ignored.

Regards,
Svend

Hello Milorad,

Thanks for your explanation.

Does it work in edge time mode?

For me it it not clear why to set the TxPR precount. It is (believing the ref manual) only important with the one shot or downcount modes but NOT in the capture mode. In this modes it become an extension to the TAR register. But 'GPTimerCC26XX_getValue' only reads the TAR register.

When capturing the count on an edge, does the CC2650 move the actual counter value 16:24 (the precount extension) into the upper TAR?

On the other hand, the manual says in chapter 13.4.3. in step 5 to write the prescale value. 

I think the manual is a little confusing to me.

Hello Thomas,

This is described in the TAR register:

Timer A Register

This register shows the current value of the Timer A counter in all cases except for Input Edge Count and Time modes. In the Input Edge Count mode, this register contains the number of edges that have occurred.  In the Input Edge Time mode, this register contains the time at which the last edge event took place.

When a GPT is configured to one of the 32-bit modes, this register appears as a 32-bit register (the upper 16-bits correspond to the contents of the Timer B (TBR) register). In

the16-bit Input Edge Count, Input Edge Time, and PWM modes, bits 15:0 contain the value of the counter and bits 23:16 contain the value of the prescaler, which is the upper 8 bits of the count. Bits 31:24 always read as 0. To read the value of the prescaler in 16-bit One-Shot and Periodic modes, read bits [23:16] in the TAV register. To read the value of the prescalar in periodic snapshot mode, read the Timer A Prescale Snapshot (TAPS) register.

Regards,
Svend

Thanks again for the clarification Svend.

I get it now. The use of the term 'prescaler' in relation to input capture edge time was confusing...but I see now it's just a way to get a 24 bit timer for 'free' essentially. I've tested it out, and it's working as expected.

Thanks!

-Ben

Milorad,

I ended up using your code, and just wanted to say thanks. You saved me a ton of time, and I really appreciate it.

Thats all ;P

-Ben

Glad I could help, Ben.

Regards,

Milorad

Hello everyone!

I try to use this driver with tirtos 2.18 and BLE SDK 2.2.

I follow guide in post to do changes for use with tirtos >=2.13.

My project will compile successful, but OS crashes. I have the exception and looped While construction:

/*
 *  ======== Hwi_excHandler ========
 */
Void Hwi_excHandler(UInt *excStack, UInt lr)
{
    Hwi_module->excActive[0] = TRUE;

    /* spin here if no exception handler is plugged */
    while (Hwi_excHandlerFunc == NULL) {
	;
    }

    Hwi_excHandlerFunc(excStack, lr);
}

the study of ROV view has revealed:

Something unknown exception.

Please help!

Andrew,

The timer has only PWM support in split mode. Since the prescaler is always used by the PWM driver you get 16+8= 24 bits resolution.

Regards

Svend

Thank you for your reply. So i will try to use pwm driver wich is available in 2.2.0 stack.  Any example project may help me. 
What about  ADC driver? is it  available in in new stack,? 

Hi,

Can I use TI-RTOS 2.21.0.06 with an example project (Project Zero, imported from SimpleLink Academy 1.8)?  Is there a porting guide?  I've tried updating the path variable TI_RTOS_DRIVERS_BASE but that produces an Invalid Location error for RF.c.

Or is the recommended approach to persist with 2.18.0.03 and copy across the driver files from 2.21.0.06?  It's all a little confusing with the TI Resource Explorer examples still using the 2.01 stack, and the RTOS still 2.20.00.06 - would hope these would be made the most up-to-date so this can become the single place of reference.  

Regards,

Evan

OK, thanks.  I think that's working now.

The problem was solved when i copied all drivers from TI-RTOS 2.20 except folder "rf"

Hi, 

thanks for your reply. 
I need to process it directly (converting it to microvolts and sending it out via UART) .
Is that doable in some way? 

Hi, 

Thanks again for your reply sending does not have to be real time although if that is possible it would be a bonus. 
I tried processing several samples at a time and then sending them out via UART but my method still required to much power and thus the time constraints weren't met. 
I would appreciate a suggestion on how to do this. 

Thank you 

Beatrice