pos_nano.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2004-2006, Dennis Kuschel.
 *  All rights reserved. 
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *   2. 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.
 *   3. The name of the author may not be used to endorse or promote
 *      products derived from this software without specific prior written
 *      permission. 
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 *
 */


#ifndef _POS_NANO_H
#define _POS_NANO_H

#ifndef DOX
#define DOX  0
#endif



/*---------------------------------------------------------------------------
 *  NANO LAYER INSTALLATION
 *-------------------------------------------------------------------------*/

/* include configuration files */
#ifndef _PICOOS_H
#include <port.h>
#include <poscfg.h>
#endif
#include <noscfg.h>


#ifndef NOSCFG_FEATURE_REGISTRY
#define NOSCFG_FEATURE_REGISTRY  0
#endif

#if POSCFG_TASKSTACKTYPE==0
#define NOS_NEEDTASKEXITHOOK
#else
#if NOSCFG_FEATURE_REGISTRY!=0
#define NOS_NEEDTASKEXITHOOK
#endif
#endif

#ifdef NOS_NEEDTASKEXITHOOK

/* define hook */
#ifdef POSCFG_TASKEXIT_HOOK
#undef POSCFG_TASKEXIT_HOOK
#endif
#define POSCFG_TASKEXIT_HOOK  1

/* set additional task data for the nano layer */
#define NOS_TASKDATA  void *nosstkroot;

#endif /* NOS_NEEDTASKEXITHOOK */

/* include pico]OS header if not yet done */
#ifndef _PICOOS_H
#include <picoos.h>
#endif



/*---------------------------------------------------------------------------
 *  CONFIGURATION
 *-------------------------------------------------------------------------*/

#ifndef NOSCFG_FEATURE_MEMALLOC
#error  NOSCFG_FEATURE_MEMALLOC not defined
#endif
#ifndef NOSCFG_FEATURE_CONIN
#error  NOSCFG_FEATURE_CONIN not defined
#endif
#ifndef NOSCFG_FEATURE_CONOUT
#error  NOSCFG_FEATURE_CONOUT not defined
#endif
#ifndef NOSCFG_CONOUT_HANDSHAKE
#error  NOSCFG_CONOUT_HANDSHAKE not defined
#endif
#ifndef NOSCFG_CONOUT_FIFOSIZE
#error  NOSCFG_CONOUT_FIFOSIZE not defined
#endif
#ifndef NOSCFG_FEATURE_PRINTF
#error  NOSCFG_FEATURE_PRINTF not defined
#endif
#ifndef NOSCFG_FEATURE_SPRINTF
#error  NOSCFG_FEATURE_SPRINTF not defined
#endif
#ifndef NOSCFG_FEATURE_TASKCREATE
#error  NOSCFG_FEATURE_TASKCREATE not defined
#endif
#ifndef NOSCFG_DEFAULT_STACKSIZE
#error  NOSCFG_DEFAULT_STACKSIZE not defined in the port configuration file
#endif
#ifndef NOSCFG_STACK_GROWS_UP
#error  NOSCFG_STACK_GROWS_UP not defined in the port configuration file
#endif
#ifndef NOSCFG_MEM_MANAGE_MODE
#error  NOSCFG_MEM_MANAGE_MODE not defined
#endif
#ifndef NOSCFG_FEATURE_MEMSET
#error  NOSCFG_FEATURE_MEMSET not defined
#endif
#ifndef NOSCFG_FEATURE_MEMCOPY
#error  NOSCFG_FEATURE_MEMCOPY not defined
#endif
#ifndef NOSCFG_STKMEM_RESERVE
#error  NOSCFG_STKMEM_RESERVE not defined
#endif
#if NOSCFG_MEM_MANAGER_TYPE == 2
#ifndef NOSCFG_MEM_USER_MALLOC
#error  NOSCFG_MEM_USER_MALLOC not defined
#endif
#ifndef NOSCFG_MEM_USER_FREE
#error  NOSCFG_MEM_USER_FREE not defined
#endif
#endif
#ifndef NOSCFG_FEATURE_BOTTOMHALF
#error  NOSCFG_FEATURE_BOTTOMHALF not defined
#endif
#if NOSCFG_FEATURE_BOTTOMHALF != 0
#ifndef NOS_MAX_BOTTOMHALFS
#error  NOS_MAX_BOTTOMHALFS not defined
#endif
#if (NOS_MAX_BOTTOMHALFS == 0) || (NOS_MAX_BOTTOMHALFS > MVAR_BITS)
#error NOS_MAX_BOTTOMHALFS must be in the range 1 .. MVAR_BITS
#endif
#endif
#ifndef NOSCFG_FEATURE_CPUUSAGE
#error  NOSCFG_FEATURE_CPUUSAGE not defined
#endif

#if NOSCFG_FEATURE_REGISTRY
#ifndef NOSCFG_FEATURE_REGQUERY
#error  NOSCFG_FEATURE_REGQUERY
#endif
#ifndef NOSCFG_FEATURE_USERREG
#error  NOSCFG_FEATURE_USERREG
#endif
#ifndef NOS_MAX_REGKEYLEN
#error  NOS_MAX_REGKEYLEN
#endif
#if NOS_MAX_REGKEYLEN < 4
#error NOS_MAX_REGKEYLEN must be at least 4
#endif
#ifndef NOS_REGKEY_PREALLOC
#error  NOS_REGKEY_PREALLOC
#endif
#else /* NOSCFG_FEATURE_REGISTRY */
#ifdef NOSCFG_FEATURE_USERREG
#undef NOSCFG_FEATURE_USERREG
#endif
#define NOSCFG_FEATURE_USERREG 0
#ifdef NOSCFG_FEATURE_REGQUERY
#undef NOSCFG_FEATURE_REGQUERY
#endif
#define NOSCFG_FEATURE_REGQUERY 0
#endif  /* NOSCFG_FEATURE_REGISTRY */

#ifndef NOSCFG_FEATURE_SEMAPHORES
#define NOSCFG_FEATURE_SEMAPHORES  0
#endif

#if NOSCFG_FEATURE_SEMAPHORES != 0  &&  POSCFG_FEATURE_SEMAPHORES == 0
#error NOSCFG_FEATURE_SEMAPHORES enabled, but pico]OS semaphores disabled
#endif

#ifndef NOSCFG_FEATURE_MUTEXES
#define NOSCFG_FEATURE_MUTEXES  0
#endif
#if NOSCFG_FEATURE_MUTEXES != 0  &&  POSCFG_FEATURE_MUTEXES == 0
#error NOSCFG_FEATURE_MUTEXES enabled, but pico]OS mutexes disabled
#endif

#ifndef NOSCFG_FEATURE_MSGBOXES
#define NOSCFG_FEATURE_MSGBOXES  0
#endif
#if NOSCFG_FEATURE_MSGBOXES != 0  &&  POSCFG_FEATURE_MSGBOXES == 0
#error NOSCFG_FEATURE_MSGBOXES enabled, but pico]OS message boxes disabled
#endif

#ifndef NOSCFG_FEATURE_FLAGS
#define NOSCFG_FEATURE_FLAGS  0
#endif
#if NOSCFG_FEATURE_FLAGS != 0  &&  POSCFG_FEATURE_FLAGS == 0
#error NOSCFG_FEATURE_FLAGS enabled, but pico]OS flag functions disabled
#endif

#ifndef NOSCFG_FEATURE_TIMER
#define NOSCFG_FEATURE_TIMER  0
#endif
#if NOSCFG_FEATURE_TIMER != 0  &&  POSCFG_FEATURE_TIMER == 0
#error NOSCFG_FEATURE_TIMER enabled, but pico]OS timer functions disabled
#endif

#ifndef NOSCFG_MEM_OVWR_STANDARD
#define NOSCFG_MEM_OVWR_STANDARD  1
#endif
#ifndef NOSCFG_FEATURE_REALLOC
#define NOSCFG_FEATURE_REALLOC    0
#endif



/*---------------------------------------------------------------------------
 *  DATA TYPES
 *-------------------------------------------------------------------------*/

#if DOX!=0 || NOSCFG_FEATURE_BOTTOMHALF != 0

typedef void (*NOSBHFUNC_t)(void* arg, UVAR_t bh);
#endif



/*---------------------------------------------------------------------------
 *  MEMORY MANAGEMENT
 *-------------------------------------------------------------------------*/

#ifdef _N_MEM_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

#if DOX!=0 || NOSCFG_FEATURE_MEMALLOC != 0

NANOEXT void* nosMemAlloc(UINT_t size);

NANOEXT void  nosMemFree(void *p);


#if DOX!=0 || NOSCFG_FEATURE_REALLOC != 0

NANOEXT void *nosMemRealloc(void *memblock, UINT_t size);
#endif

/* overwrite standard memory allocation functions */
#ifndef NANOINTERNAL
#if NOSCFG_MEM_OVWR_STANDARD != 0
#ifdef malloc
#undef malloc
#endif
#ifdef calloc
#undef calloc
#endif
#ifdef free
#undef free
#endif
#define malloc  nosMemAlloc
#define calloc  (not_supported)
#define free    nosMemFree
#endif /* NOSCFG_MEM_OVWR_STANDARD */
#else /* NANOINTERNAL */
/* internal malloc/free, used by OS core and platform ports */
#if NOSCFG_MEM_MANAGER_TYPE == 0
#define NOS_MEM_ALLOC(x)   malloc((size_t)(x))
#define NOS_MEM_FREE(x)    free(x)
#elif   NOSCFG_MEM_MANAGER_TYPE == 1
void*   nos_malloc(UINT_t size);
void    nos_free(void *mp);
#define NOS_MEM_ALLOC(x)   nos_malloc(x)
#define NOS_MEM_FREE(x)    nos_free(x)
#elif   NOSCFG_MEM_MANAGER_TYPE == 2
#define NOS_MEM_ALLOC(x)   NOSCFG_MEM_USER_MALLOC(x)
#define NOS_MEM_FREE(x)    NOSCFG_MEM_USER_FREE(x)
#endif
#endif /* NANOINTERNAL */

#endif /* NOSCFG_FEATURE_MEMALLOC */

#if DOX!=0 || NOSCFG_FEATURE_MEMSET != 0

NANOEXT void nosMemSet(void *buf, char val, UINT_t count);

#if NOSCFG_MEM_OVWR_STANDARD != 0
#ifdef memset
#undef memset
#endif
#define memset  nosMemSet
#endif

#endif /* NOSCFG_FEATURE_MEMSET */

#if DOX!=0 || NOSCFG_FEATURE_MEMCOPY != 0

NANOEXT void nosMemCopy(void *dst, void *src, UINT_t count);

#if NOSCFG_MEM_OVWR_STANDARD != 0
#ifdef memcpy
#undef memcpy
#endif
#define memcpy  nosMemCopy
#endif

#endif /* NOSCFG_FEATURE_MEMCOPY */
#undef NANOEXT

/*---------------------------------------------------------------------------
 *  CONSOLE INPUT / OUTPUT
 *-------------------------------------------------------------------------*/

#ifdef _N_CONIO_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

#if DOX!=0 || NOSCFG_FEATURE_CONIN != 0

NANOEXT void  c_nos_keyinput(UVAR_t key);

NANOEXT char  nosKeyGet(void);

NANOEXT UVAR_t  nosKeyPressed(void);

#endif  /* NOSCFG_FEATURE_CONIN */


#if DOX!=0 || NOSCFG_FEATURE_CONOUT != 0

NANOEXT UVAR_t  p_putchar(char c); 
#endif


#if DOX!=0 || NOSCFG_CONOUT_HANDSHAKE != 0

NANOEXT void  c_nos_putcharReady(void);
#endif


#if DOX!=0 || NOSCFG_FEATURE_CONOUT != 0

NANOEXT void  nosPrintChar(char c);

NANOEXT void  nosPrint(const char *s);

#endif

#if NOSCFG_FEATURE_CONOUT == 0
#if NOSCFG_FEATURE_PRINTF != 0
#undef  NOSCFG_FEATURE_PRINTF
#define NOSCFG_FEATURE_PRINTF  0
#endif
#endif

#if NOSCFG_FEATURE_PRINTF != 0 || NOSCFG_FEATURE_SPRINTF != 0
typedef void* NOSARG_t;
#endif


#if DOX!=0 || ((NOSCFG_FEATURE_CONOUT != 0)&&(NOSCFG_FEATURE_PRINTF != 0))

NANOEXT void n_printFormattedN(const char *fmt, NOSARG_t args);

#if DOX

NANOEXT void nosPrintf1(const char *fmt, arg a1);

#else /* DOX!=0 */
#define nosPrintf1(fmt, a1)  \
  do { \
    NOSARG_t args[1]; args[0] = (NOSARG_t)(a1); \
    n_printFormattedN(fmt, args); \
  } while(0);

#define nosPrintf2(fmt, a1, a2)  \
  do { \
    NOSARG_t args[2]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); \
    n_printFormattedN(fmt, args); \
  } while(0);

#define nosPrintf3(fmt, a1, a2, a3)  \
  do { \
    NOSARG_t args[3]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); args[2] = (NOSARG_t)(a3); \
    n_printFormattedN(fmt, args); \
  } while(0);

#define nosPrintf4(fmt, a1, a2, a3, a4)  \
  do { \
    NOSARG_t args[4]; \
    args[0] = (NOSARG_t)(a1); args[1] = (NOSARG_t)(a2); \
    args[2] = (NOSARG_t)(a3); args[3] = (NOSARG_t)(a4); \
    n_printFormattedN(fmt, args); \
  } while(0);

#define nosPrintf5(fmt, a1, a2, a3, a4, a5)  \
  do { \
    NOSARG_t args[5]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); args[2] = (NOSARG_t)(a3); \
    args[3] = (NOSARG_t)(a4); args[4] = (NOSARG_t)(a5); \
    n_printFormattedN(fmt, args); \
  } while(0);

#define nosPrintf6(fmt, a1, a2, a3, a4, a5, a6)  \
  do { \
    NOSARG_t args[6]; \
    args[0] = (NOSARG_t)(a1); args[1] = (NOSARG_t)(a2); \
    args[2] = (NOSARG_t)(a3); args[3] = (NOSARG_t)(a4); \
    args[4] = (NOSARG_t)(a5); args[5] = (NOSARG_t)(a6); \
    n_printFormattedN(fmt, args); \
  } while(0);

#endif /* DOX!=0 */
#endif /* NOSCFG_FEATURE_PRINTF */


#if DOX!=0 || NOSCFG_FEATURE_SPRINTF != 0
#if DOX

NANOEXT void nosSPrintf1(char *buf, const char *fmt, arg a1);

#else /* DOX!=0 */

NANOEXT void n_sprintFormattedN(char *buf, const char *fmt, NOSARG_t args);

#define nosSPrintf1(buf, fmt, a1)  \
  do { \
    NOSARG_t args[1]; args[0] = (NOSARG_t)(a1); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#define nosSPrintf2(buf, fmt, a1, a2)  \
  do { \
    NOSARG_t args[2]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#define nosSPrintf3(buf, fmt, a1, a2, a3)  \
  do { \
    NOSARG_t args[3]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); args[2] = (NOSARG_t)(a3); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#define nosSPrintf4(buf, fmt, a1, a2, a3, a4)  \
  do { \
    NOSARG_t args[4]; \
    args[0] = (NOSARG_t)(a1); args[1] = (NOSARG_t)(a2); \
    args[2] = (NOSARG_t)(a3); args[3] = (NOSARG_t)(a4); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#define nosSPrintf5(buf, fmt, a1, a2, a3, a4, a5)  \
  do { \
    NOSARG_t args[5]; args[0] = (NOSARG_t)(a1); \
    args[1] = (NOSARG_t)(a2); args[2] = (NOSARG_t)(a3); \
    args[3] = (NOSARG_t)(a4); args[4] = (NOSARG_t)(a5); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#define nosSPrintf6(buf, fmt, a1, a2, a3, a4, a5, a6)  \
  do { \
    NOSARG_t args[6]; \
    args[0] = (NOSARG_t)(a1); args[1] = (NOSARG_t)(a2); \
    args[2] = (NOSARG_t)(a3); args[3] = (NOSARG_t)(a4); \
    args[4] = (NOSARG_t)(a5); args[5] = (NOSARG_t)(a6); \
    n_sprintFormattedN(buf, fmt, args); \
  } while(0);

#endif /* DOX!=0 */
#endif /* NOSCFG_FEATURE_SPRINTF */
#undef NANOEXT

/*---------------------------------------------------------------------------
 *  BOTTOM HALFS
 *-------------------------------------------------------------------------*/

#ifdef _N_BHALF_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

#if DOX!=0 || NOSCFG_FEATURE_BOTTOMHALF != 0

NANOEXT VAR_t  nosBottomHalfRegister(UVAR_t number, NOSBHFUNC_t func,
                                     void *arg);

#define nosBottomHalfUnregister(number) \
          nosBottomHalfRegister(number, NULL, NULL)

NANOEXT void nosBottomHalfStart(UVAR_t number);

#endif /* NOSCFG_FEATURE_BOTTOMHALF */
#undef NANOEXT

/*---------------------------------------------------------------------------
 *  REGISTRY
 *-------------------------------------------------------------------------*/

#ifdef _N_REG_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0

typedef void*  NOSGENERICHANDLE_t;

typedef void*  NOSREGQHANDLE_t;

/* Generic registry key value type.
   It is on the developer how he uses the type. */
typedef union {
  void*       voidptr; 
  int         integer; 
} KEYVALUE_t;

typedef enum {
  REGTYPE_TASK = 0,    
#if DOX!=0 || NOSCFG_FEATURE_SEMAPHORES != 0
  REGTYPE_SEMAPHORE,   
#endif
#if DOX!=0 || NOSCFG_FEATURE_MUTEXES != 0
  REGTYPE_MUTEX,       
#endif
#if DOX!=0 || NOSCFG_FEATURE_FLAGS != 0
  REGTYPE_FLAG,        
#endif
#if DOX!=0 || NOSCFG_FEATURE_TIMER != 0
  REGTYPE_TIMER,       
#endif
#if DOX!=0 || NOSCFG_FEATURE_USERREG != 0
  REGTYPE_USER,        
#endif
  REGTYPE_SEARCHALL    
} NOSREGTYPE_t;
#define MIN_REGTYPE  REGTYPE_TASK
#define MAX_REGTYPE  (REGTYPE_SEARCHALL-1)


NANOEXT NOSGENERICHANDLE_t  nosGetHandleByName(
                                 NOSREGTYPE_t objtype, const char *objname);


NANOEXT VAR_t nosGetNameByHandle(NOSGENERICHANDLE_t handle,
                                 char *buffer, VAR_t bufsize,
                                 NOSREGTYPE_t what);

#if DOX!=0  ||  NOSCFG_FEATURE_USERREG != 0

NANOEXT VAR_t nosRegSet(const char *keyname, KEYVALUE_t keyvalue);

NANOEXT VAR_t nosRegGet(const char *keyname, KEYVALUE_t *keyvalue);

NANOEXT VAR_t nosRegDel(const char *keyname);
#endif

#if DOX!=0 || NOSCFG_FEATURE_REGQUERY != 0

NANOEXT NOSREGQHANDLE_t  nosRegQueryBegin(NOSREGTYPE_t type);

NANOEXT VAR_t nosRegQueryElem(NOSREGQHANDLE_t qh, NOSGENERICHANDLE_t *genh,
                              char* namebuf, VAR_t bufsize);

NANOEXT void nosRegQueryEnd(NOSREGQHANDLE_t qh);
#endif

#endif /* NOSCFG_FEATURE_REGISTRY */
#undef NANOEXT

/*---------------------------------------------------------------------------
 *  CPU USAGE
 *-------------------------------------------------------------------------*/

#if (DOX!=0) || (NOSCFG_FEATURE_CPUUSAGE != 0)

UVAR_t nosCpuUsage(void);
#endif

/*---------------------------------------------------------------------------
 *  ABSTRACTED FUNCTIONS
 *-------------------------------------------------------------------------*/

#ifdef _N_CORE_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

typedef  POSTASK_t  NOSTASK_t;


#if (DOX!=0) || (NOSCFG_FEATURE_TASKCREATE != 0)

NANOEXT NOSTASK_t nosTaskCreate(POSTASKFUNC_t funcptr, void *funcarg,
                                VAR_t priority, UINT_t stacksize,
                                const char* name);


#if (DOX!=0) || (POSCFG_FEATURE_YIELD != 0)

#if DOX
NANOEXT void nosTaskYield(void);
#else
#define nosTaskYield()  posTaskYield()
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_SLEEP != 0)

#if DOX
NANOEXT void nosTaskSleep(UINT_t ticks);
#else
#define nosTaskSleep(ticks)  posTaskSleep(ticks)
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_EXIT != 0)

#if DOX
NANOEXT void nosTaskExit(void);
#else
#define nosTaskExit()  posTaskExit()
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_GETTASK != 0)

#if DOX
NANOEXT NOSTASK_t nosTaskGetCurrent(void);
#else
#define nosTaskGetCurrent()  (NOSTASK_t)posTaskGetCurrent()
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_TASKUNUSED != 0)

#if DOX
NANOEXT VAR_t nosTaskUnused(NOSTASK_t taskhandle);
#else
#define nosTaskUnused(th)  posTaskUnused((POSTASK_t)(th))
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_SETPRIORITY != 0)

#if DOX
NANOEXT VAR_t nosTaskSetPriority(NOSTASK_t taskhandle, VAR_t priority);
#else
#define nosTaskSetPriority(th, prio) posTaskSetPriority((POSTASK_t)(th),prio)
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_GETPRIORITY != 0)

#if DOX
NANOEXT VAR_t nosTaskGetPriority(NOSTASK_t taskhandle);
#else
#define nosTaskGetPriority(th)  posTaskGetPriority((POSTASK_t)(th))
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_INHIBITSCHED != 0)

#if DOX
NANOEXT void nosTaskSchedLock(void);
#else
#define nosTaskSchedLock()  posTaskSchedLock()
#endif

#if DOX
NANOEXT void nosTaskSchedUnlock(void);
#else
#define nosTaskSchedUnlock()  posTaskSchedUnlock()
#endif
#endif

#if (DOX!=0) || (POSCFG_TASKCB_USERSPACE > 0)

#if DOX
NANOEXT void* nosTaskGetUserspace(void);
#else
#define nosTaskGetUserspace()  posTaskGetUserspace()
#endif
#endif

#if (DOX!=0) || (POSCFG_FEATURE_IDLETASKHOOK != 0)

typedef POSIDLEFUNC_t NOSIDLEFUNC_t;
#if DOX
NANOEXT NOSIDLEFUNC_t nosInstallIdleTaskHook(NOSIDLEFUNC_t idlefunc);
#else
#define nosInstallIdleTaskHook(ifunc)  posInstallIdleTaskHook(ifunc)
#endif
#endif

#endif

#if DOX!=0 || NOSCFG_FEATURE_SEMAPHORES != 0

typedef  POSSEMA_t  NOSSEMA_t;

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT NOSSEMA_t nosSemaCreate(INT_t initcount, UVAR_t options,
                                const char *name);
#else
#define nosSemaCreate(i, o, n)  (NOSSEMA_t) posSemaCreate(i);
#endif

#if DOX!=0 || POSCFG_FEATURE_SEMADESTROY != 0

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT void nosSemaDestroy(NOSSEMA_t sema);
#else
#define nosSemaDestroy(sema)  posSemaDestroy((POSSEMA_t)(sema))
#endif
#endif

#if DOX

NANOEXT  VAR_t nosSemaSignal(NOSSEMA_t sema);
#else
#define nosSemaSignal(sem)  posSemaSignal((POSSEMA_t)(sem))
#endif

#if DOX

NANOEXT VAR_t nosSemaGet(NOSSEMA_t sema);
#else
#define nosSemaGet(sem)  posSemaGet((POSSEMA_t)(sem))
#endif

#if DOX

NANOEXT VAR_t nosSemaWait(NOSSEMA_t sema, UINT_t timeoutticks);
#else
#if POSCFG_FEATURE_SEMAWAIT
#define nosSemaWait(sem, to)  posSemaWait((POSSEMA_t)(sem), to)
#endif
#endif

#endif /* POSCFG_FEATURE_SEMAPHORES */

#if DOX!=0 || NOSCFG_FEATURE_MUTEXES != 0

typedef  POSMUTEX_t  NOSMUTEX_t;

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT NOSMUTEX_t nosMutexCreate(UVAR_t options, const char *name);
#else
#define nosMutexCreate(opt, name)  (NOSMUTEX_t) posMutexCreate()
#endif

#if DOX!=0 || POSCFG_FEATURE_MUTEXDESTROY != 0

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT void nosMutexDestroy(NOSMUTEX_t mutex);
#else
#define nosMutexDestroy(mutex)  posMutexDestroy((POSMUTEX_t)(mutex))
#endif
#endif

#if DOX!=0 || POSCFG_FEATURE_MUTEXTRYLOCK != 0

#if DOX
NANOEXT VAR_t nosMutexTryLock(NOSMUTEX_t mutex);
#else
#define nosMutexTryLock(mutex)  posMutexTryLock((POSMUTEX_t)(mutex))
#endif
#endif

#if DOX
NANOEXT VAR_t nosMutexLock(NOSMUTEX_t mutex);
#else
#define nosMutexLock(mutex)  posMutexLock((POSMUTEX_t)(mutex))
#endif

#if DOX
NANOEXT VAR_t nosMutexUnlock(NOSMUTEX_t mutex);
#else
#define nosMutexUnlock(mutex)  posMutexUnlock((POSMUTEX_t)(mutex))
#endif

#endif /* NOSCFG_FEATURE_MUTEXES */

#if DOX!=0 || NOSCFG_FEATURE_MSGBOXES != 0

NANOEXT void* nosMessageAlloc(UINT_t msgSize);

NANOEXT void nosMessageFree(void *buf);

NANOEXT VAR_t nosMessageSend(void *buf, NOSTASK_t taskhandle);

#if DOX
NANOEXT void* nosMessageGet(void);
#else
#define  nosMessageGet()  posMessageGet()
#endif

#if DOX!=0 || POSCFG_FEATURE_MSGWAIT != 0

#if DOX
NANOEXT void* nosMessageWait(UINT_t timeoutticks);
#else
#define nosMessageWait(to)  posMessageWait(to)
#endif
#endif

#if DOX
NANOEXT VAR_t nosMessageAvailable(void);
#else
#define nosMessageAvailable()  posMessageAvailable()
#endif

#endif  /* NOSCFG_FEATURE_MSGBOXES */

#if DOX!=0 || NOSCFG_FEATURE_FLAGS != 0

typedef  POSFLAG_t  NOSFLAG_t;

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT NOSFLAG_t nosFlagCreate(const char* name);
#else
#define nosFlagCreate(name)  (NOSFLAG_t) posFlagCreate()
#endif

#if DOX!=0 || POSCFG_FEATURE_FLAGDESTROY != 0

#if (DOX!=0) || (NOSCFG_FEATURE_REGISTRY != 0)
NANOEXT void nosFlagDestroy(NOSFLAG_t flg);
#else
#define nosFlagDestroy(flg)  posFlagDestroy((POSFLAG_t)(flg))
#endif
#endif

#if DOX
NANOEXT VAR_t nosFlagSet(NOSFLAG_t flg, UVAR_t flgnum);
#else
#define nosFlagSet(flg, num)  posFlagSet((POSFLAG_t)(flg), num)
#endif

#if DOX
NANOEXT VAR_t nosFlagGet(NOSFLAG_t flg, UVAR_t mode);
#else
#define nosFlagGet(flg, mode)  posFlagGet((POSFLAG_t)(flg), mode)
#endif

#if DOX!=0 || POSCFG_FEATURE_FLAGWAIT != 0

#if DOX
NANOEXT VAR_t nosFlagWait(NOSFLAG_t flg, UINT_t timeoutticks);
#else
#define nosFlagWait(flg, to)  posFlagWait((POSFLAG_t)(flg), to)
#endif
#endif

#define NOSFLAG_MODE_GETSINGLE  POSFLAG_MODE_GETSINGLE
#define NOSFLAG_MODE_GETMASK    POSFLAG_MODE_GETMASK

#endif /* NOSCFG_FEATURE_FLAGS */

#if DOX!=0 || NOSCFG_FEATURE_TIMER != 0

typedef  POSTIMER_t  NOSTIMER_t;

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT NOSTIMER_t  nosTimerCreate(const char *name);
#else
#define nosTimerCreate(name)  (NOSTIMER_t) posTimerCreate()
#endif

#if DOX
NANOEXT VAR_t nosTimerSet(NOSTIMER_t tmr, NOSSEMA_t sema,
                          UINT_t waitticks, UINT_t periodticks);
#else
#define nosTimerSet(t, s, w, p) \
          posTimerSet((POSTIMER_t)(t), (POSSEMA_t)(s), w, p)
#endif

#if DOX
NANOEXT VAR_t nosTimerStart(NOSTIMER_t tmr);
#else
#define nosTimerStart(tmr)  posTimerStart((POSTIMER_t)(tmr))
#endif

#if DOX
NANOEXT VAR_t nosTimerStop(NOSTIMER_t tmr);
#else
#define nosTimerStop(tmr)  posTimerStop((POSTIMER_t)(tmr))
#endif

#if DOX!=0 || POSCFG_FEATURE_TIMERDESTROY != 0

#if DOX!=0 || NOSCFG_FEATURE_REGISTRY != 0
NANOEXT void nosTimerDestroy(NOSTIMER_t tmr);
#else
#define nosTimerDestroy(tmr)  posTimerDestroy((POSTIMER_t)(tmr))
#endif
#endif

#if DOX!=0 || POSCFG_FEATURE_TIMERFIRED != 0

#if DOX
NANOEXT VAR_t nosTimerFired(NOSTIMER_t tmr);
#else
#define nosTimerFired(tmr)  posTimerFired((POSTIMER_t)(tmr))
#endif
#endif

#endif /* NOSCFG_FEATURE_TIMER */

#undef NANOEXT

/*---------------------------------------------------------------------------
 *  INITIALIZATION
 *-------------------------------------------------------------------------*/

#ifdef _N_CORE_C
#define NANOEXT
#else
#define NANOEXT extern
#endif

NANOEXT void  nosInit(POSTASKFUNC_t firstfunc, void *funcarg, VAR_t priority,
                      UINT_t taskStackSize, UINT_t idleStackSize);

#ifndef _N_CORE_C
#ifndef _POSCORE_C
#define posInit _Please_use_nosInit_instead_of_posInit_
#endif
#endif
#undef NANOEXT

#endif /* _POS_NANO_H */

---