static void test_nano_timers(int unused1, int unused2)
{
struct nano_timer timer;
ARG_UNUSED(unused1);
ARG_UNUSED(unused2);
nano_timer_init(&timer, (void *)0xdeadbeef);
TC_PRINT("starting nano timer to expire in %d seconds\n",
TEST_NANO_TIMERS_DELAY);
nano_fiber_timer_start(&timer, SECONDS(TEST_NANO_TIMERS_DELAY));
TC_PRINT("fiber pending on timer\n");
nano_fiber_timer_wait(&timer);
TC_PRINT("fiber back from waiting on timer: giving semaphore.\n");
nano_task_sem_give(&test_nano_timers_sem);
TC_PRINT("fiber semaphore given.\n");
/* on failure, don't give semaphore, main test will not obtain it */
}
void fiberEntry(void)
{
struct nano_timer timer;
uint32_t data[2] = {0, 0};
nano_sem_init(&nanoSemFiber);
nano_timer_init(&timer, data);
while (1) {
/* wait for task to let us have a turn */
nano_fiber_sem_take_wait(&nanoSemFiber);
/* say "hello" */
PRINT("%s: Hello World!\n", __FUNCTION__);
/* wait a while, then let task have a turn */
nano_fiber_timer_start(&timer, SLEEPTICKS);
nano_fiber_timer_wait(&timer);
nano_fiber_sem_give(&nanoSemTask);
}
}
void fiber3(void)
{
void *pData;
/* Wait for fiber3 to be activated */
nano_fiber_sem_take_wait(&nanoSemObj3);
/* Put two items onto <nanoFifoObj2> to unblock fibers #1 and #2. */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[0]); /* Wake fiber1 */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[1]); /* Wake fiber2 */
/* Wait for fiber3 to be re-activated */
nano_fiber_sem_take_wait(&nanoSemObj3);
/* Immediately get the data from <nanoFifoObj2>. */
pData = nano_fiber_fifo_get_wait(&nanoFifoObj2);
if (pData != pPutList2[0]) {
retCode = TC_FAIL;
TC_ERROR("fiber3 (1) - got 0x%x from <nanoFifoObj2>, expected 0x%x\n",
pData, pPutList2[0]);
}
/* Put three items onto the FIFO for the task to get */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[0]);
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[1]);
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[2]);
/* Sleep for 2 seconds */
nano_fiber_timer_start(&timer, SECONDS(2));
nano_fiber_timer_wait(&timer);
/* Put final item onto the FIFO for the task to get */
nano_fiber_fifo_put(&nanoFifoObj2, pPutList2[3]);
/* Wait for fiber3 to be re-activated (not expected to occur) */
nano_fiber_sem_take_wait(&nanoSemObj3);
}
static void fiberEntry(int arg1, int arg2)
{
int rv; /* return value from a test */
ARG_UNUSED(arg1);
ARG_UNUSED(arg2);
rv = testSemFiberNoWait();
if (rv != TC_PASS) {
return;
}
/*
* At this point <testSem> is not available. Wait for <testSem> to become
* available (the main task will give it).
*/
nano_fiber_sem_take_wait(&testSem);
semTestState = STS_TASK_WOKE_FIBER;
/*
* Delay for two seconds. This gives the main task time to print
* any messages (very important if I/O link is slow!), and wait
* on <testSem>. Once the delay is done, this fiber will give <testSem>
* thus waking the main task.
*/
nano_fiber_timer_start(&timer, SECONDS(2));
nano_fiber_timer_wait(&timer);
/*
* The main task is now waiting on <testSem>. Give the semaphore <testSem>
* to wake it.
*/
nano_fiber_sem_give(&testSem);
/*
* Some small delay must be done so that the main task can process the
* semaphore signal.
*/
semTestState = STS_FIBER_WOKE_TASK;
nano_fiber_timer_start(&timer, SECONDS(2));
nano_fiber_timer_wait(&timer);
/*
* The main task should be waiting on <testSem> again. This time, instead
* of giving the semaphore from the semaphore, give it from an ISR to wake
* the main task.
*/
isrSemInfo.data = 0;
isrSemInfo.sem = &testSem;
_trigger_nano_isr_sem_give();
if (isrSemInfo.data == 1) {
semTestState = STS_ISR_WOKE_TASK;
}
}
/**
* Main function of the timer task. This function is in charge of
* calling the callbacks associated with the timers.
*
* This function is run in a high priority task on microkernel builds.
* This function is run in a high priority fiber on nanokernel builds.
* It implements an infinite loop that waits for any of the semaphores from
* g_TimerSem.
* When a semaphore is signaled, this function fetches the pointer to the
* associated callback in g_TimerDesc, then calls it.
*
* @param dummy1 not used (required by ZEPHYR API)
* @param dummy2 not used (required by ZEPHYR API) *
*
*/
void timer_task(int dummy1, int dummy2)
{
uint32_t timeout;
uint32_t now;
UNUSED(dummy1);
UNUSED(dummy2);
timeout = OS_WAIT_FOREVER;
while (1) /* the Timer task shall never stop */
{
#ifdef CONFIG_MICROKERNEL /********************** MICRO KERNEL SPECIFIC: */
/* block until g_TimerSem is signaled or until the next timeout expires */
(void) task_sem_take_wait_timeout(g_TimerSem, timeout);
#else
if (NULL == g_CurrentTimerHead)
{
/* Start a background timer with max positive delay */
nano_fiber_timer_start (&g_NanoTimer, 0x7FFFFFFF);
/* wait until the next timer expires or one is added or removed */
nano_fiber_timer_wait (&g_NanoTimer);
}
#endif
now = _GET_TICK();
/* task is unblocked: check for expired timers */
while (is_after_expiration (now, &(g_CurrentTimerHead->desc)))
{
execute_callback(g_CurrentTimerHead);
}
/* Compute timeout until the expiration of the next timer */
if ( NULL != g_CurrentTimerHead )
{
now = _GET_TICK();
/* In micro kernel context, timeout = 0 or timeout < 0 works.
* In nano kernel context timeout must be a positive value.
*/
#ifdef CONFIG_NANOKERNEL
if (g_CurrentTimerHead->desc.expiration > now)
{
#endif
timeout = g_CurrentTimerHead->desc.expiration - now;
if (OS_WAIT_FOREVER == timeout)
{ /* cannot have timeout = OS_WAIT_FOREVER while there is
still at least one active timer */
timeout++;
}
#ifdef CONFIG_NANOKERNEL
nano_fiber_timer_start (&g_NanoTimer, timeout);
/* wait until the next timer expires or one is added or removed */
nano_fiber_timer_wait (&g_NanoTimer);
/* nano_fiber_timer_wait will wait until "natural" timer
* expiration, or until nano_fiber_timer_stop(&g_NanoTimer)
* is called by the timer_callback or by timer_stop() */
}
#endif
}
#ifdef CONFIG_MICROKERNEL
else
{
timeout = OS_WAIT_FOREVER;
}
#endif
#ifdef __DEBUG_OS_ABSTRACTION_TIMER
if (NULL != g_CurrentTimerHead )
_log ("\nINFO : timer_task : now = %u, next timer expires at %u, timeout = %u", _GET_TICK() , g_CurrentTimerHead->desc.expiration, timeout );
else
_log ("\nINFO : timer_task : now = %u, no next timer, timeout = OS_WAIT_FOREVER", _GET_TICK() );
#endif
} /* end while(1) */
}
