n_core.c

picoos源码。The RTOS and the TCP/IP stack will be built automatically.

/*---------------------------------------------------------------------------
 * NANO LAYER FLAG FUNCTIONS
 *-------------------------------------------------------------------------*/

#if NOSCFG_FEATURE_FLAGS != 0
#if NOSCFG_FEATURE_REGISTRY != 0

NOSFLAG_t nosFlagCreate(const char* name)
{
  POSFLAG_t flg;
  REGELEM_t re;

  re = nos_regNewSysKey(REGTYPE_FLAG,
                        name == NULL ? (const char*)"f*" : name);
  if (re == NULL)
    return NULL;

  flg = posFlagCreate();
  if (flg == NULL)
  {
    nos_regDelSysKey(REGTYPE_FLAG, NULL, re);
  }
  else
  {
    nos_regEnableSysKey(re, flg);
    POS_SETEVENTNAME(flg, re->name);
  }
  return (NOSFLAG_t) flg;
}

#if POSCFG_FEATURE_FLAGDESTROY != 0

void nosFlagDestroy(NOSFLAG_t flg)
{
  if (flg != NULL)
  {
    nos_regDelSysKey(REGTYPE_FLAG, flg, NULL);
    posFlagDestroy((POSFLAG_t) flg);
  }
}

#endif /* POSCFG_FEATURE_FLAGDESTROY */

#endif /* NOSCFG_FEATURE_REGISTRY */
#endif /* NOSCFG_FEATURE_FLAGS */



/*---------------------------------------------------------------------------
 * NANO LAYER TIMER FUNCTIONS
 *-------------------------------------------------------------------------*/

#if NOSCFG_FEATURE_TIMER != 0
#if NOSCFG_FEATURE_REGISTRY != 0

NOSTIMER_t nosTimerCreate(const char *name)
{
  POSTIMER_t tmr;
  REGELEM_t re;

  re = nos_regNewSysKey(REGTYPE_TIMER, 
                        name == NULL ? (const char*)"r*" : name);
  if (re == NULL)
    return NULL;

  tmr = posTimerCreate();
  if (tmr == NULL)
  {
    nos_regDelSysKey(REGTYPE_TIMER, NULL, re);
  }
  else
  {
    nos_regEnableSysKey(re, tmr);
  }
  return (NOSTIMER_t) tmr;
}

void nosTimerDestroy(NOSTIMER_t tmr)
{
  if (tmr != NULL)
  {
    nos_regDelSysKey(REGTYPE_TIMER, tmr, NULL);
    posTimerDestroy((POSTIMER_t) tmr);
  }
}

#endif /* NOSCFG_FEATURE_REGISTRY */
#endif /* NOSCFG_FEATURE_TIMER */



/*---------------------------------------------------------------------------
 *  NANO LAYER TASK FUNCTIONS
 *-------------------------------------------------------------------------*/

#ifdef NOS_NEEDTASKEXITHOOK

static void nos_taskExitHook(POSTASK_t task, texhookevent_t event);
static void nos_taskExitHook(POSTASK_t task, texhookevent_t event)
{
#if NOSCFG_FEATURE_REGISTRY != 0
  if (event == texh_exitcalled)
    nos_regDelSysKey(REGTYPE_TASK, task, NULL);
#endif
#if POSCFG_TASKSTACKTYPE == 0
  if (event == texh_freestackmem)
    NOS_MEM_FREE(task->nosstkroot);
#endif
}

#endif /* NOS_NEEDTASKEXITHOOK */

/*-------------------------------------------------------------------------*/

#if NOSCFG_FEATURE_TASKCREATE != 0

#ifdef NOS_NEEDTASKEXITHOOK
#if POSCFG_FEATURE_INHIBITSCHED == 0
#error POSCFG_FEATURE_INHIBITSCHED not enabled
#endif
#endif

NOSTASK_t nosTaskCreate(POSTASKFUNC_t funcptr, void *funcarg,
                        VAR_t priority, UINT_t stacksize,
                        const char* name)
{
  POSTASK_t task;
#if NOSCFG_FEATURE_REGISTRY != 0
  REGELEM_t re;
#endif
#if POSCFG_TASKSTACKTYPE == 0
  void *stk;
#endif

#if NOSCFG_FEATURE_REGISTRY != 0
  re = nos_regNewSysKey(REGTYPE_TASK,
                        name == NULL ? (const char*)"t*" : name);
  if (re == NULL)
    return NULL;
#else
  (void) name;
#endif

  /*===============================================*/
#if POSCFG_TASKSTACKTYPE == 0

  if (stacksize == 0)
    stacksize = NOSCFG_DEFAULT_STACKSIZE;

  task = NULL;
  stk = nosMemAlloc(NOSCFG_STKMEM_RESERVE + stacksize);
  if (stk != NULL)
  {
    posTaskSchedLock();
#if NOSCFG_STACK_GROWS_UP == 0
    task = posTaskCreate(funcptr, funcarg, priority, 
                         (void*) (((MEMPTR_t)stk) + stacksize -
                                  (NOSCFG_STKMEM_RESERVE + 1)));
#else
    task = posTaskCreate(funcptr, funcarg, priority,
                         (void*) (((MEMPTR_t)stk) + NOSCFG_STKMEM_RESERVE));
#endif
    if (task != NULL)
    {
      task->nosstkroot = stk;
      task->exithook   = nos_taskExitHook;
#if NOSCFG_FEATURE_REGISTRY != 0
      nos_regEnableSysKey(re, task);
      POS_SETTASKNAME(task, re->name);
#else
      POS_SETTASKNAME(task, name);
#endif
    }
    posTaskSchedUnlock();

#if POSCFG_FEATURE_SLEEP != 0
    posTaskSleep(0);
#elif POSCFG_FEATURE_YIELD != 0
    posTaskYield();
#endif
  }

  /*-----------------------------------------------*/
#elif POSCFG_TASKSTACKTYPE == 1

  if (stacksize == 0)
    stacksize = NOSCFG_DEFAULT_STACKSIZE;

#if NOSCFG_FEATURE_REGISTRY != 0
  posTaskSchedLock();
#endif

  task = posTaskCreate(funcptr, funcarg, priority, stacksize);

#if NOSCFG_FEATURE_REGISTRY != 0
  if (task != NULL)
  {
    task->exithook = nos_taskExitHook;
    nos_regEnableSysKey(re, task);
    POS_SETTASKNAME(task, re->name);
  }
  posTaskSchedUnlock();
#else
  POS_SETTASKNAME(task, name);
#endif

  /*-----------------------------------------------*/
#elif POSCFG_TASKSTACKTYPE == 2

#if NOSCFG_FEATURE_REGISTRY != 0
  posTaskSchedLock();
#endif

  (void) stacksize;
  task = posTaskCreate(funcptr, funcarg, priority);

#if NOSCFG_FEATURE_REGISTRY != 0
  if (task != NULL)
  {
    task->exithook = nos_taskExitHook;
    nos_regEnableSysKey(re, task);
    POS_SETTASKNAME(task, re->name);
  }
  posTaskSchedUnlock();
#else
  POS_SETTASKNAME(task, name);
#endif

#endif /* POSCFG_TASKSTACKTYPE == 2 */

  /*===============================================*/
#if NOSCFG_FEATURE_REGISTRY != 0
  if (task == NULL)
  {
    nos_regDelSysKey(REGTYPE_TASK, NULL, re);
  }
#endif

  return (POSTASK_t) task;
}

#endif /* NOSCFG_FEATURE_TASKCREATE != 0 */



/*---------------------------------------------------------------------------
 *  NANO LAYER INITIALIZATION
 *-------------------------------------------------------------------------*/

static void nano_init(void *arg)
{
#if NOSCFG_FEATURE_REGISTRY != 0
  REGELEM_t re;
#endif
  POS_SETTASKNAME(posCurrentTask_g, "root task");
#if POSCFG_TASKSTACKTYPE == 0
  posCurrentTask_g->nosstkroot = arg;
  posCurrentTask_g->exithook = nos_taskExitHook;
#else
  (void) arg;
#if NOSCFG_FEATURE_REGISTRY != 0
  posCurrentTask_g->exithook = nos_taskExitHook;
#endif
#endif

#if NOSCFG_FEATURE_CPUUSAGE != 0
  nano_initCpuUsage();
#endif
#if NOSCFG_FEATURE_REGISTRY != 0
  nos_initRegistry();
#endif
#if (NOSCFG_FEATURE_CONIN != 0) || (NOSCFG_FEATURE_CONOUT != 0)
  nos_initConIO();
#endif
#if NOSCFG_FEATURE_BOTTOMHALF != 0
  nos_initBottomHalfs();
#endif

#if NOSCFG_FEATURE_REGISTRY != 0
  re = nos_regNewSysKey(REGTYPE_TASK, "root-task");
  if (re != NULL)
  {
    nos_regEnableSysKey(re, posTaskGetCurrent());
  }
#endif

  (taskparams_g.func)(taskparams_g.arg);
}

/*-------------------------------------------------------------------------*/

void  nosInit(POSTASKFUNC_t firstfunc, void *funcarg, VAR_t priority,
              UINT_t taskStackSize, UINT_t idleStackSize)
{
#if POSCFG_TASKSTACKTYPE == 0
  void *stk_task1, *stk_idle;
#endif

  taskparams_g.func = firstfunc;
  taskparams_g.arg  = funcarg;

#if (NOSCFG_FEATURE_MEMALLOC != 0) && (NOSCFG_MEM_MANAGER_TYPE == 1)
  nos_initMem();
#endif

#if POSCFG_TASKSTACKTYPE == 0

  if (taskStackSize == 0)
    taskStackSize = NOSCFG_DEFAULT_STACKSIZE;
  if (idleStackSize == 0)
    idleStackSize = NOSCFG_DEFAULT_STACKSIZE;
  stk_task1 = NOS_MEM_ALLOC(NOSCFG_STKMEM_RESERVE + taskStackSize);
  stk_idle  = NOS_MEM_ALLOC(NOSCFG_STKMEM_RESERVE + idleStackSize);
  if ((stk_task1 != NULL) && (stk_idle != NULL))
  {
#if NOSCFG_STACK_GROWS_UP == 0
    posInit(nano_init, stk_task1, priority,
            (void*) (((MEMPTR_t)stk_task1) + taskStackSize -
                     (NOSCFG_STKMEM_RESERVE + 1)),
            (void*) (((MEMPTR_t)stk_idle) + idleStackSize -
                     (NOSCFG_STKMEM_RESERVE + 1)) );
#else
    posInit(nano_init, stk_task1, priority,
            (void*) (((MEMPTR_t)stk_task1) + NOSCFG_STKMEM_RESERVE),
            (void*) (((MEMPTR_t)stk_idle) + NOSCFG_STKMEM_RESERVE) );
#endif
  }

#elif POSCFG_TASKSTACKTYPE == 1

  if (taskStackSize == 0)
    taskStackSize = NOSCFG_DEFAULT_STACKSIZE;
  if (idleStackSize == 0)
    idleStackSize = NOSCFG_DEFAULT_STACKSIZE;
  posInit(nano_init, NULL, priority, taskStackSize, idleStackSize);

#elif POSCFG_TASKSTACKTYPE == 2

  (void) taskStackSize;
  (void) idleStackSize;
  posInit(nano_init, NULL, priority);

#endif
}