RTOS/CC2642R: debugging problem by adding a task to the sample project (ble5_simple_peripheral_cc26x2r1lp_app)

/*
 * second_task.c
 *
 *  Created on: Jan 31, 2019
 *      Author: a0226836
 */

#include <ti/sysbios/knl/Task.h>

#include <icall.h>
#include "util.h"
#include "comdef.h"


typedef uint8_t status_t;

static void SecondTask_taskFxn(UArg a0, UArg a1);
static void SecondTask_init(void);
static void SecondTask_clockHandler(UArg arg);
static status_t SecondTask_enqueueMsg(uint8_t event, void *pData);




#define PERIODIC_EVT                      0


// Internal Events for RTOS application
#define QUEUE_EVT                         UTIL_QUEUE_EVENT_ID // Event_Id_30

// Bitwise OR of all RTOS events to pend on
#define ALL_EVENTS                        (QUEUE_EVT)



// How often to perform periodic event (in ms)
#define PERIODIC_EVT_PERIOD               5000



// App event passed from stack modules. This type is defined by the application
// since it can queue events to itself however it wants.
typedef struct
{
  uint8_t event;                // event type
  void    *pData;               // pointer to message
} stEvt_t;

// Entity ID globally used to check for source and/or destination of messages
static ICall_EntityID selfEntity;
// Event globally used to post local events and pend on system and
// local events.
static ICall_SyncHandle syncEvent;

// Queue object used for app messages
static Queue_Struct appMsgQueue;
static Queue_Handle appMsgQueueHandle;

// Clock instance for internal periodic events.
static Clock_Struct clkPeriodic;

static volatile uint16_t periodicCounter = 0;

Task_Struct task;
uint8_t taskStack[1024];








void SecondTask_createTask(void)
{
  Task_Params taskParams;

  // Configure task
  Task_Params_init(&taskParams);
  taskParams.stack = taskStack;
  taskParams.stackSize = 1024;
  taskParams.priority = 1;

  Task_construct(&task, SecondTask_taskFxn, &taskParams, NULL);
}




static void SecondTask_taskFxn(UArg a0, UArg a1)
{
  // Initialize application
    SecondTask_init();

  // Application main loop
  for (;;)
  {
    uint32_t events;

    // Waits for an event to be posted associated with the calling thread.
    // Note that an event associated with a thread is posted when a
    // message is queued to the message receive queue of the thread
    events = Event_pend(syncEvent, Event_Id_NONE, ALL_EVENTS,
                        ICALL_TIMEOUT_FOREVER);

    if (events)
    {
      // If RTOS queue is not empty, process app message.
      if (events & QUEUE_EVT)
      {
        while (!Queue_empty(appMsgQueueHandle))
        {
          stEvt_t *pMsg = (stEvt_t *)Util_dequeueMsg(appMsgQueueHandle);
          if (pMsg)
          {
                switch (pMsg->event)
                {
                  case PERIODIC_EVT:
                      periodicCounter++;


                    break;

                  default:
                    // Do nothing.
                    break;
                }

            // Free the space from the message.
            ICall_free(pMsg);
          }
        }
      }
    }
  }
}


static void SecondTask_init(void)
{
  // ******************************************************************
  // N0 STACK API CALLS CAN OCCUR BEFORE THIS CALL TO ICall_registerApp
  // ******************************************************************
  // Register the current thread as an ICall dispatcher application
  // so that the application can send and receive messages.
  ICall_registerApp(&selfEntity, &syncEvent);

  // Create an RTOS queue for message from profile to be sent to app.
  appMsgQueueHandle = Util_constructQueue(&appMsgQueue);

  // Create 5s clock for internal periodic events.
  Util_constructClock(&clkPeriodic, SecondTask_clockHandler,
                      PERIODIC_EVT_PERIOD, PERIODIC_EVT_PERIOD, true, NULL);

}

static void SecondTask_clockHandler(UArg arg)
{
   // Post event to read the current RPA
   SecondTask_enqueueMsg(PERIODIC_EVT, NULL);
}

static status_t SecondTask_enqueueMsg(uint8_t event, void *pData)
{
  uint8_t success;
  stEvt_t *pMsg = ICall_malloc(sizeof(stEvt_t));

  // Create dynamic pointer to message.
  if(pMsg)
  {
    pMsg->event = event;
    pMsg->pData = pData;

    // Enqueue the message.
    success = Util_enqueueMsg(appMsgQueueHandle, syncEvent, (uint8_t *)pMsg);
    return (success) ? SUCCESS : FAILURE;
  }

  return(FAILURE);
}