CC1310外部RTC定时开启无线接受

我看到SDK的例程里面有rfWsnNode，我现在想是否有定时接受数据，不是WakeOnRadioRx的方法。我现在做的是一种被动式的应用，节点是低功耗外部RTC定时醒来，进入接受模式，开启100ms，然后进入到睡眠。请问有这样的应用案例吗？谢谢！

你的目的是什么?低功耗吗? 开启100ms接收窗口,功耗还是比较大的.

不知道怎么用RTC吗? 参考如下回复,100ms的话,可以使用TI-RTOS的clock

The RTC is used by TI-RTOS as the time base for the ti.sysbios.Clock module. It continues to run even when the processor is in standby mode and will wake the processor whenever a Clock object times out.

Clock objects are used to implement the timeouts for BIOS APIs such as Task_sleep(), Semaphore_pend(), Event_pend(), etc. They are also used internally by various TI-RTOS driver functions when a timeout is required.

The RTC is also used as the timebase for the ti.sysbios.hal.Seconds module which can be used to provide time-of-day information to your application.

下面是使用clock的例子

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

@file util.c

@brief This file contains utility functions commonly used by
BLE applications for CC26xx with TIRTOS.

Group: WCS, BTS
Target Device: CC2650, CC2640, CC1350

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

Copyright (c) 2014-2016, Texas Instruments Incorporated
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

* Neither the name of Texas Instruments Incorporated nor the names of
its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

******************************************************************************
Release Name: ble_sdk_2_02_01_18
Release Date: 2016-10-26 15:20:04
*****************************************************************************/

/*********************************************************************
* INCLUDES
*/
#include <stdbool.h>
#include <ti/sysbios/knl/Clock.h>
#ifdef ICALL_EVENTS
#include <ti/sysbios/knl/Event.h>
#else //!ICALL_EVENTS
#include <ti/sysbios/knl/Semaphore.h>
#endif //ICALL_EVENTS
#include <ti/sysbios/knl/Queue.h>
#include <ti/sysbios/hal/Hwi.h>

#ifdef USE_ICALL
#include <icall.h>
#else
#include <stdlib.h>
#endif

#include "bcomdef.h"
#include "util.h"

/*********************************************************************
* TYPEDEFS
*/

// RTOS queue for profile/app messages.
typedef struct _queueRec_
{
Queue_Elem _elem; // queue element
uint8_t *pData; // pointer to app data
} queueRec_t;

/*********************************************************************
* LOCAL FUNCTIONS
*/

/*********************************************************************
* EXTERNAL VARIABLES
*/

/*********************************************************************
* LOCAL VARIABLES
*/

/*********************************************************************
* PUBLIC FUNCTIONS
*/

/*********************************************************************
* @fn Util_constructClock
*
* @brief Initialize a TIRTOS Clock instance.
*
* @param pClock - pointer to clock instance structure.
* @param clockCB - callback function upon clock expiration.
* @param clockDuration - longevity of clock timer in milliseconds
* @param clockPeriod - if set to a value other than 0, the first
* expiry is determined by clockDuration. All
* subsequent expiries use the clockPeriod value.
* @param startFlag - TRUE to start immediately, FALSE to wait.
* @param arg - argument passed to callback function.
*
* @return Clock_Handle - a handle to the clock instance.
*/
Clock_Handle Util_constructClock(Clock_Struct *pClock,
Clock_FuncPtr clockCB,
uint32_t clockDuration,
uint32_t clockPeriod,
uint8_t startFlag,
UArg arg)
{
Clock_Params clockParams;

// Convert clockDuration in milliseconds to ticks.
uint32_t clockTicks = clockDuration * (1000 / Clock_tickPeriod);

// Setup parameters.
Clock_Params_init(&clockParams);

// Setup argument.
clockParams.arg = arg;

// If period is 0, this is a one-shot timer.
clockParams.period = clockPeriod * (1000 / Clock_tickPeriod);

// Starts immediately after construction if true, otherwise wait for a call
// to start.
clockParams.startFlag = startFlag;

// Initialize clock instance.
Clock_construct(pClock, clockCB, clockTicks, &clockParams);

return Clock_handle(pClock);
}

/*********************************************************************
* @fn Util_startClock
*
* @brief Start a clock.
*
* @param pClock - pointer to clock struct
*
* @return none
*/
void Util_startClock(Clock_Struct *pClock)
{
Clock_Handle handle = Clock_handle(pClock);

// Start clock instance
Clock_start(handle);
}

/*********************************************************************
* @fn Util_restartClock
*
* @brief Restart a clock by changing the timeout.
*
* @param pClock - pointer to clock struct
* @param clockTimeout - longevity of clock timer in milliseconds
*
* @return none
*/
void Util_restartClock(Clock_Struct *pClock, uint32_t clockTimeout)
{
uint32_t clockTicks;
Clock_Handle handle;

handle = Clock_handle(pClock);

if (Clock_isActive(handle))
{
// Stop clock first
Clock_stop(handle);
}

// Convert timeout in milliseconds to ticks.
clockTicks = clockTimeout * (1000 / Clock_tickPeriod);

// Set the initial timeout
Clock_setTimeout(handle, clockTicks);

// Start clock instance
Clock_start(handle);
}

/*********************************************************************
* @fn Util_isActive
*
* @brief Determine if a clock is currently active.
*
* @param pClock - pointer to clock struct
*
* @return TRUE if Clock is currently active
FALSE otherwise
*/
bool Util_isActive(Clock_Struct *pClock)
{
Clock_Handle handle = Clock_handle(pClock);

// Start clock instance
return Clock_isActive(handle);
}

/*********************************************************************
* @fn Util_stopClock
*
* @brief Stop a clock.
*
* @param pClock - pointer to clock struct
*
* @return none
*/
void Util_stopClock(Clock_Struct *pClock)
{
Clock_Handle handle = Clock_handle(pClock);

// Stop clock instance
Clock_stop(handle);
}

/*********************************************************************
* @fn Util_rescheduleClock
*
* @brief Reschedule a clock by changing the timeout and period values.
*
* @param pClock - pointer to clock struct
* @param clockPeriod - longevity of clock timer in milliseconds
* @return none
*/
void Util_rescheduleClock(Clock_Struct *pClock, uint32_t clockPeriod)
{
bool running;
uint32_t clockTicks;
Clock_Handle handle;

handle = Clock_handle(pClock);
running = Clock_isActive(handle);

if (running)
{
Clock_stop(handle);
}

// Convert period in milliseconds to ticks.
clockTicks = clockPeriod * (1000 / Clock_tickPeriod);

Clock_setTimeout(handle, clockTicks);
Clock_setPeriod(handle, clockTicks);

if (running)
{
Clock_start(handle);
}
}

/*********************************************************************
* @fn Util_constructQueue
*
* @brief Initialize an RTOS queue to hold messages to be processed.
*
* @param pQueue - pointer to queue instance structure.
*
* @return A queue handle.
*/
Queue_Handle Util_constructQueue(Queue_Struct *pQueue)
{
// Construct a Queue instance.
Queue_construct(pQueue, NULL);

return Queue_handle(pQueue);
}

/*********************************************************************
* @fn Util_enqueueMsg
*
* @brief Creates a queue node and puts the node in RTOS queue.
*
* @param msgQueue - queue handle.
* @param sem - thread's event processing semaphore that queue is
* associated with.
* @param pMsg - pointer to message to be queued
*
* @return TRUE if message was queued, FALSE otherwise.
*/
uint8_t Util_enqueueMsg(Queue_Handle msgQueue,
#ifdef ICALL_EVENTS
Event_Handle event,
#else //!ICALL_EVENTS
Semaphore_Handle sem,
#endif //ICALL_EVENTS
uint8_t *pMsg)
{
queueRec_t *pRec;

// Allocated space for queue node.
#ifdef USE_ICALL
if ((pRec = ICall_malloc(sizeof(queueRec_t))))
#else
if ((pRec = (queueRec_t *)malloc(sizeof(queueRec_t))))
#endif
{
pRec->pData = pMsg;

// This is an atomic operation
Queue_put(msgQueue, &pRec->_elem);

// Wake up the application thread event handler.
#ifdef ICALL_EVENTS
if (event)
{
Event_post(event, UTIL_QUEUE_EVENT_ID);
}
#else //!ICALL_EVENTS
if (sem)
{
Semaphore_post(sem);
}
#endif //ICALL_EVENTS

return TRUE;
}

// Free the message.
#ifdef USE_ICALL
ICall_free(pMsg);
#else
free(pMsg);
#endif

return FALSE;
}

/*********************************************************************
* @fn Util_dequeueMsg
*
* @brief Dequeues the message from the RTOS queue.
*
* @param msgQueue - queue handle.
*
* @return pointer to dequeued message, NULL otherwise.
*/
uint8_t *Util_dequeueMsg(Queue_Handle msgQueue)
{
queueRec_t *pRec = Queue_get(msgQueue);

if (pRec != (queueRec_t *)msgQueue)
{
uint8_t *pData = pRec->pData;

// Free the queue node
// Note: this does not free space allocated by data within the node.
#ifdef USE_ICALL
ICall_free(pRec);
#else
free(pRec);
#endif

return pData;
}

return NULL;
}

/*********************************************************************
* @fn Util_convertBdAddr2Str
*
* @brief Convert Bluetooth address to string. Only needed when
* LCD display is used.
*
* @param pAddr - BD address
*
* @return BD address as a string
*/
char *Util_convertBdAddr2Str(uint8_t *pAddr)
{
uint8_t charCnt;
char hex[] = "0123456789ABCDEF";
static char str[(2*B_ADDR_LEN)+3];
char *pStr = str;

*pStr++ = '0';
*pStr++ = 'x';

// Start from end of addr
pAddr += B_ADDR_LEN;

for (charCnt = B_ADDR_LEN; charCnt > 0; charCnt--)
{
*pStr++ = hex[*--pAddr >> 4];
*pStr++ = hex[*pAddr & 0x0F];
}
pStr = NULL;

return str;
}

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