avrx.h

#ifndef _AVRX_H_
#  define _AVRX_H_

#  include <avrio/defs.h>

__BEGIN_C_DECLS
  /* ======================================================================== */
#  if defined(__DOXYGEN__)
  /* macros ================================================================= */
#  define AVRX_DECLARE_TASK(task_name, stack_size, priority)

#  define AVRX_FUNC(task_name)

#  define AVRX_TASK(task_name, stack_size, priority)

#  define AVRX_EXTERN_TASK(task_name)

#  define AVRX_NAKED_FUNC(task_name)

#  define PID(task_name)

#  define TCB(task_name)

#  define xAvrXInitTask (task_name);

#  define vAvrXRunTask (task_name);

  /* structures ============================================================= */
  typedef struct xProcess {} xProcess;

  typedef struct xTcb {} xTcb;

  typedef struct xMessage {} xMessage;

  typedef struct xMessageQueue {} xMessageQueue;

  typedef struct xTimer {} xTimer;

  typedef struct xTimerMessage {} xTimerMessage;

  /* types ================================================================ */

  typedef xProcess * xPid;

  typedef xPid xSem;


#  else   /* __DOXYGEN__ not defined */
  //----------------------------------------------------------------------------
  typedef struct xProcess {

    struct xProcess * next;
    uint8_t flags;
    uint8_t priority;
    void * ContextPointer;
#   ifdef AVRX_SINGLESTEP_ENABLE
      uint8_t * bp1;
      uint8_t * bp2;
#   endif
  } xProcess;

  //----------------------------------------------------------------------------
  typedef xProcess * xPid;

  //----------------------------------------------------------------------------
  typedef xPid xSem;

  //----------------------------------------------------------------------------
  typedef struct {

    void * r_stack;       // Start of stack (top address-1)
    void (*start) (void); // Entry point of code
    xPid pid;             // Pointer to Process block
    uint8_t priority;     // Priority of task (0-255)
  } FLASH const xTcb;

  //----------------------------------------------------------------------------
  typedef struct xMessage {

    struct xMessage *next;
    xSem semaphore;
  } xMessage;

  //----------------------------------------------------------------------------
  typedef struct xMessageQueue {
    xMessage * message; // List of messages
    xPid pid;           // List of processes
  } xMessageQueue;


  //----------------------------------------------------------------------------
  typedef struct xTimer {
    struct xTimer *next;
    xSem semaphore;
    uint16_t count;
  } xTimer;

  //----------------------------------------------------------------------------
  typedef struct xTimerMessage {
    union {
      struct xMessage mcb;
      struct xTimer tcb;
    } u;
    struct xMessageQueue *queue;
  } xTimerMessage;

#  endif  /* __DOXYGEN__ not defined */

  /* internal public functions ============================================== */
  void vAvrXStart (void);

  void vAvrXResume (xPid xP);

  void vAvrXSuspend (xPid xP);

   void vAvrXYield(void);

  void vAvrXTaskExit (void);

  void vAvrXTerminate (xPid xP);

  void vAvrXWaitTask (xPid xP);

  xSem xAvrXTestPid (xPid xP);

  uint8_t xAvrXPriority (xPid xP);

  uint8_t xAvrXChangePriority (xPid xP, uint8_t xNewPriority);

  xPid pxAvrXSelf (void);

  void * pvAvrXSetKernelStack (void * pNewStack);

  void vAvrXIntReschedule(void);

  xPid xAvrXInitTcb (xTcb * pxTcb);

  void vAvrXRunTcb (xTcb * pxTcb);

  void vAvrXHalt (void);

  uint8_t xAvrXSingleStep (xPid xP);

  uint8_t xAvrXSingleStepNext (xPid xP);

    /* constants ============================================================ */
#   define AVRX_PEND ((xSem)0)

#   define AVRX_DONE ((xSem)1)

#   define AVRX_WAIT ((xSem)2)

    /* internal public functions ============================================ */
    void vAvrXSetSemaphore (xSem * pxSem);

    void vAvrXWaitSemaphore (xSem * pxSem);

    xSem xAvrXTestSemaphore (xSem * pxSem);

    void vAvrXResetSemaphore (xSem * pxSem);

    void vAvrXResetObjectSemaphore (xSem * pxSem);

    void vAvrXIntSetSemaphore (xSem * pxSem);

    xSem xAvrXIntTestSemaphore (xSem * pxSem);

    /* internal public functions ============================================ */

    void vAvrXSendMessage (xMessageQueue * pxQueue, xMessage * pxMessage);

    void vAvrXIntSendMessage (xMessageQueue * pxQueue, xMessage * pxMessage);

    xMessage * pxAvrXRecvMessage (xMessageQueue * pxQueue);

    xMessage * pxAvrXWaitMessage (xMessageQueue * pxQueue);

    void vAvrXAckMessage (xMessage * pxMessage);

    void vAvrXWaitMessageAck (xMessage * pxMessage);

    xSem xAvrXTestMessageAck (xMessage * pxMessage);

    /* internal public functions ============================================ */
    void vAvrXStartTimer (xTimer * pxTimer, uint16_t xTicksWait);

    xTimer * pxAvrXCancelTimer (xTimer * pxTimer);

    void vAvrXWaitTimer (xTimer * pxTimer);

    void vAvrXDelay (xTimer * pxTimer, uint16_t xTicksWait);

    xSem xAvrXTestTimer (xTimer * pxTimer);

    void vAvrXStartTimerMessage ( xTimerMessage * pxTimer,
                                  uint16_t xTicksWait, xMessageQueue * pxQueue);

    xMessage * pxAvrXCancelTimerMessage (xTimerMessage * pxTimer,
                                                     xMessageQueue * pxQueue);
    /* internal public functions ============================================ */

    uint8_t ucAvrXReadEEProm (const uint8_t * pucAddress);

    uint16_t usAvrXReadEEPromWord (const uint16_t * pusAddress);

    void vAvrXWriteEEProm (uint8_t * pucAddress, uint8_t ucByte);
#  if !defined(__DOXYGEN__)
  /*
   * __DOXYGEN__ not defined
   * Partie ne devant pas être documentée.
   * =========================================================================
   */
#  define MINCONTEXT 35  // 32 registers, return address and SREG

#  define AVRX_NAKED_FUNC(function) void function(void) NAKED;\
    void function(void)

#  define AVRX_FUNC(function) void function(void) CTASK;\
    void function(void)

#  define AVRX_DECLARE_TASK(task_name, stack_size, priority)  \
    char task_name ## Stk [stack_size + MINCONTEXT] ; \
    AVRX_FUNC(task_name); \
    xProcess task_name ## Pid; \
    xTcb task_name ## Tcb = \
    { \
        &task_name##Stk[sizeof(task_name##Stk)-1] , \
        task_name, \
        &task_name##Pid, \
        priority \
    }

#  define AVRX_TASK(task_name, stack_size, priority) \
    AVRX_DECLARE_TASK(task_name, stack_size, priority); \
    AVRX_FUNC(task_name)

#  define AVRX_EXTERN_TASK(task_name) \
    AVRX_FUNC(task_name);       \
    extern xTcb task_name##Tcb; \
    extern xProcess task_name##Pid

#  define PID(task_name) (&task_name##Pid)

#  define TCB(task_name) (&task_name##Tcb)

#  define xAvrXInitTask(task_name) xAvrXInitTcb(TCB(task_name))

#  define vAvrXRunTask(task_name) vAvrXRunTcb(TCB(task_name))

#  endif /* __DOXYGEN__ not defined */

  /* ======================================================================== */
__END_C_DECLS
#endif /* _AVRX_H_ not defined */