void fiber1(void)
{
void *pData; /* pointer to FIFO object get from the queue */
int count = 0; /* counter */
/* Wait for fiber1 to be activated. */
nano_fiber_sem_take_wait(&nanoSemObj1);
/* Wait for data to be added to <nanoFifoObj> by task */
pData = nano_fiber_fifo_get_wait(&nanoFifoObj);
if (pData != pPutList1[0]) {
TC_ERROR("fiber1 (1) - expected 0x%x, got 0x%x\n",
pPutList1[0], pData);
retCode = TC_FAIL;
return;
}
/* Wait for data to be added to <nanoFifoObj2> by fiber3 */
pData = nano_fiber_fifo_get_wait(&nanoFifoObj2);
if (pData != pPutList2[0]) {
TC_ERROR("fiber1 (2) - expected 0x%x, got 0x%x\n",
pPutList2[0], pData);
retCode = TC_FAIL;
return;
}
nano_fiber_sem_take_wait(&nanoSemObj1); /* Wait for fiber1 to be reactivated */
TC_PRINT("Test Fiber FIFO Get\n\n");
/* Get all FIFOs */
while ((pData = nano_fiber_fifo_get(&nanoFifoObj)) != NULL) {
TC_PRINT("FIBER FIFO Get: count = %d, ptr is %p\n", count, pData);
if ((count >= NUM_FIFO_ELEMENT) || (pData != pPutList1[count])) {
TCERR1(count);
retCode = TC_FAIL;
return;
}
count++;
}
TC_END_RESULT(retCode);
PRINT_LINE;
/*
* Entries in the FIFO queue have to be unique.
* Put data.
*/
TC_PRINT("Test Fiber FIFO Put\n");
TC_PRINT("\nFIBER FIFO Put Order: ");
for (int i=0; i<NUM_FIFO_ELEMENT; i++) {
nano_fiber_fifo_put(&nanoFifoObj, pPutList2[i]);
TC_PRINT(" %p,", pPutList2[i]);
}
TC_PRINT("\n");
PRINT_LINE;
/* Give semaphore to allow the main task to run */
nano_fiber_sem_give(&nanoSemObjTask);
} /* fiber1 */
void fiber2(void)
{
void *pData; /* pointer to FIFO object from the queue */
/* Wait for fiber2 to be activated */
nano_fiber_sem_take_wait(&nanoSemObj2);
/* Wait for data to be added to <nanoFifoObj> */
pData = nano_fiber_fifo_get_wait(&nanoFifoObj);
if (pData != pPutList1[1]) {
TC_ERROR("fiber2 (1) - expected 0x%x, got 0x%x\n",
pPutList1[1], pData);
retCode = TC_FAIL;
return;
}
/* Wait for data to be added to <nanoFifoObj2> by fiber3 */
pData = nano_fiber_fifo_get_wait(&nanoFifoObj2);
if (pData != pPutList2[1]) {
TC_ERROR("fiber2 (2) - expected 0x%x, got 0x%x\n",
pPutList2[1], pData);
retCode = TC_FAIL;
return;
}
nano_fiber_sem_take_wait(&nanoSemObj2); /* Wait for fiber2 to be reactivated */
/* Fiber #2 has been reactivated by main task */
for (int i = 0; i < 4; i++) {
pData = nano_fiber_fifo_get_wait(&nanoFifoObj);
if (pData != pPutList1[i]) {
TC_ERROR("fiber2 (3) - iteration %d expected 0x%x, got 0x%x\n",
i, pPutList1[i], pData);
retCode = TC_FAIL;
return;
}
}
nano_fiber_sem_give(&nanoSemObjTask); /* Wake main task */
nano_fiber_sem_take_wait(&nanoSemObj2); /* Wait for fiber2 to be reactivated */
testFiberFifoGetW();
PRINT_LINE;
testIsrFifoFromFiber();
TC_END_RESULT(retCode);
} /* fiber2 */
static void fiber_multi_waiters(int arg1, int arg2)
{
TC_PRINT("multiple-waiter fiber %d trying to get semaphore...\n", arg1);
nano_fiber_sem_take_wait(&multi_waiters);
TC_PRINT("multiple-waiter fiber %d acquired semaphore, sending reply\n",
arg1);
nano_fiber_sem_give(&reply_multi_waiters);
}
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);
}
void lock_pool(void)
{
#ifdef ZEPHYR_MICRO_OS_ABSTRACTION_USE_SINGLE_POOL_LOCK
#ifdef CONFIG_NANOKERNEL
_PoolLock();
#else
task_mutex_lock_wait(MTX_POOL_GENERIC);
#endif
#else
#ifdef CONFIG_NANOKERNEL
nano_fiber_sem_take_wait (&QueuePoolLockSem) ;
#else
task_mutex_lock_wait(MTX_POOL_QUEUE);
#endif
#endif
}
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);
}
}
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;
}
}
