os_tmr.c

uCOS在PIC芯片中的移植：以PIC24HJ64GP210为例进行uCOS在Microchip芯片中的移植

/*
************************************************************************************************************************
*                                                      uC/OS-III
*                                                 The Real-Time Kernel
*
*                                        (c) Copyright 2005, Micrium, Weston, FL
*                                                  All Rights Reserved
*
*                                                   TIMER MANAGEMENT
*
* File    : OS_TMR.C
* By      : Jean J. Labrosse
* Version : V2.82
************************************************************************************************************************
*/

#include <ucos_ii.h>

/*
************************************************************************************************************************
*                                                        NOTES
*
* 1) Your application MUST define the following #define constants:
*
*    OS_TASK_TMR_PRIO          The priority of the Timer management task
*    OS_TASK_TMR_STK_SIZE      The size     of the Timer management task's stack
*
* 2) You must call OSTmrSignal() to notify the Timer management task that it's time to update the timers.
************************************************************************************************************************
*/

/*
************************************************************************************************************************
*                                                     CONSTANTS
************************************************************************************************************************
*/

#define  OS_TMR_LINK_DLY       0
#define  OS_TMR_LINK_PERIODIC  1

/*
************************************************************************************************************************
*                                                  LOCAL PROTOTYPES
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
static  OS_TMR  *OSTmr_Alloc     (void);
static  void     OSTmr_Free      (OS_TMR *ptmr);
static  void     OSTmr_InitTask  (void);
static  void     OSTmr_Link      (OS_TMR *ptmr, INT8U type);
static  void     OSTmr_Unlink    (OS_TMR *ptmr);
static  void     OSTmr_Lock      (void);
static  void     OSTmr_Unlock    (void);
static  void     OSTmr_Task      (void   *p_arg);
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                             GET THE NAME OF A TIMER
*
* Description: This function is called to obtain the name of a timer.
*
* Arguments  : ptmr          Is a pointer to the timer to obtain the name for
*
*              perr          Is a pointer to an error code.  '*perr' will contain one of the following:
*                               OS_NO_ERR
*                               OS_ERR_TMR_ISR            Called from an ISR
*                               OS_ERR_TMR_INVALID_DEST  'pdest' is a NULL pointer
*                               OS_ERR_TMR_INVALID       'ptmr'  is a NULL pointer
*                               OS_ERR_TMR_INACTIVE      'ptmr'  points to a timer that is not active
*
* Returns    : A copy of ptmr->OSTmrName placed in the destination string
************************************************************************************************************************
*/

#if OS_TMR_EN > 0 && OS_TMR_CFG_NAME_SIZE > 0
void  OSTmrNameGet (OS_TMR  *ptmr,
                    INT8U   *pdest,
                    INT8U   *perr)
{
#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0) {
        return;
    }
    if (pdest == (INT8U *)0) {
        *perr = OS_ERR_TMR_INVALID_DEST;
        return;
    }
    if (ptmr == (OS_TMR *)0) {
        *perr = OS_ERR_TMR_INVALID;
        return;
    }
#endif
    if (OSIntNesting > 0) {                            /* See if trying to call from an ISR                           */
        *perr  = OS_ERR_TMR_ISR;
        return;
    }
    OSTmr_Lock();
    if (ptmr->OSTmrActive == OS_FALSE) {
        OSTmr_Unlock();
        *perr = OS_ERR_TMR_INACTIVE;
        return;
    }
    OS_StrCopy(pdest, ptmr->OSTmrName);
    OSTmr_Unlock();
    *perr  = OS_NO_ERR;
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                    GET HOW MUCH TIME IS LEFT BEFORE A TIMER EXPIRES
*
* Description: This function is called to get the number of ticks before a timer times out.
*
* Arguments  : ptmr          Is a pointer to the timer to obtain the remaining time from.
*
*              perr          Is a pointer to an error code.  '*perr' will contain one of the following:
*                               OS_NO_ERR
*                               OS_ERR_TMR_ISR          Called from an ISR
*                               OS_ERR_TMR_INVALID     'ptmr' is a NULL pointer
*                               OS_ERR_TMR_INACTIVE    'ptmr' points to a timer that is not active
*
* Returns    : The time remaining for the timer to expire.  The time represents 'timer' increments.  In other words, if
*              OSTmr_Task() is signaled every 1/10 of a second then the returned value represents the number of 1/10 of
*              a second remaining before the timer expires.
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
INT32U  OSTmrRemainGet (OS_TMR  *ptmr,
                        INT8U   *perr)
{
    INT32U  remain;


    if (OSIntNesting > 0) {                            /* See if trying to call from an ISR                           */
        return (OS_ERR_TMR_ISR);
    }
#if OS_ARG_CHK_EN > 0
    if (ptmr == (OS_TMR *)0) {
        *perr = OS_ERR_TMR_INVALID;
        return (0);
    }
    if (perr == (INT8U *)0) {
        return (0);
    }
#endif
    OSTmr_Lock();
    if (ptmr->OSTmrActive == OS_FALSE) {
        OSTmr_Unlock();
        *perr = OS_ERR_TMR_INACTIVE;
        return (0);
    }
    remain = ptmr->OSTmrMatch - OSTmrTime;             /* Determine how much time is left to timeout                  */
    OSTmr_Unlock();
    *perr  = OS_NO_ERR;
    return (remain);
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                                   START A TIMER
*
* Description: This function is called by your application code to create and start a timer.
*
* Arguments  : period        The time (in OS ticks) before the timer expires.
*                               If you specified 'OS_TMR_OPT_PERIODIC' as an option, when the timer expires, it will
*                               automatically restart with the same period.
*
*              opt           Specifies either:
*                               OS_TMR_OPT_ONE_SHOT       The timer counts down only once and then is deleted
*                               OS_TMR_OPT_PERIODIC       The timer counts down and then reloads itself
*
*              callback      Is a pointer to a callback function that will be called when the timer expires.  The
*                               callback function must be declared as follows:
*
*                               void MyCallback (OS_TMR *ptmr, void *p_arg);
*
*              callback_arg  Is an argument (a pointer) that is passed to the callback function when it is called.
*
*              pname         Is a pointer to an ASCII string that is used to name the timer.  Names are useful for
*                               debugging.  The length of the ASCII string for the name is given by:
*
*                               OS_TMR_CFG_NAME_SIZE and should be found in OS_CFG.H
*
*              perr          Is a pointer to an error code.  '*perr' will contain one of the following:
*                               OS_NO_ERR
*                               OS_ERR_TMR_INVALID_PERIOD
*                               OS_ERR_TMR_INVALID_OPT
*                               OS_ERR_TMR_NON_AVAIL
*
* Returns    : A pointer to an OS_TMR data structure.  This is the 'handle' that you application will use to reference
*              the timer created/started.
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
OS_TMR  *OSTmrStart(INT32U           dly,
                    INT32U           period,
                    INT8U            opt,
                    OS_TMR_CALLBACK  callback,
                    void            *callback_arg,
                    INT8U           *pname,
                    INT8U           *perr)
{
#if OS_TMR_CFG_NAME_SIZE > 0
    INT8U         len;
#endif
    OS_TMR       *ptmr;


#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0) {                               /* Validate arguments                                     */
        return (OS_TMR *)0;
    }
    if (period == 0) {
        *perr = OS_ERR_TMR_INVALID_PERIOD;
        return (OS_TMR *)0;
    }
    if (opt != OS_TMR_OPT_ONE_SHOT && opt != OS_TMR_OPT_PERIODIC) {
        *perr = OS_ERR_TMR_INVALID_OPT;
        return (OS_TMR *)0;
    }
#endif
    OSTmr_Lock();
    ptmr = OSTmr_Alloc();                                   /* Obtain a timer from the free pool                      */
    if (ptmr == (OS_TMR *)0) {
        OSTmr_Unlock();
        *perr = OS_ERR_TMR_NON_AVAIL;
        return ((OS_TMR *)0);
    }
    ptmr->OSTmrActive      = OS_TRUE;                          /* Indicate that timer is active                          */
    ptmr->OSTmrDly         = dly;
    ptmr->OSTmrPeriod      = period;
    ptmr->OSTmrOpt         = opt;
    ptmr->OSTmrCallback    = callback;
    ptmr->OSTmrCallbackArg = callback_arg;
#if OS_TMR_CFG_NAME_SIZE > 0
    if (pname !=(INT8U *)0) {
        len = OS_StrLen(pname);                             /* Copy timer name                                        */
        if (len < OS_TMR_CFG_NAME_SIZE) {
            (void)OS_StrCopy(ptmr->OSTmrName, pname);
        }
    }
#endif

    OSTmr_Link(ptmr, OS_TMR_LINK_DLY);                      /* Link timer to timer wheel                              */

    OSTmr_Unlock();

    *perr = OS_NO_ERR;

    return (ptmr);
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                                   STOP A TIMER
*
* Description: This function is called by your application code to stop and delete a timer.
*
* Arguments  : ptmr          Is a pointer to the timer to stop and delete.
*
*              opt           Allows you to specify an option to this functions which can be:
*
*                               OS_TMR_OPT_NONE          Do nothing special but stop the timer
*                               OS_TMR_OPT_CALLBACK      Execute the callback function, pass it the callback argument
*                                                        specified when the timer was created.
*                               OS_TMR_OPT_CALLBACK_ARG  Execute the callback function, pass it the callback argument
*                                                        specified in THIS function call
*
*              callback_arg  Is a pointer to a 'new' callback argument that can be passed to the callback function
*                               instead of the timer's callback argument.  In other words, use 'callback_arg' passed in
*                               THIS function INSTEAD of ptmr->OSTmrCallbackArg
*
*              perr          Is a pointer to an error code.  '*perr' will contain one of the following:
*                               OS_NO_ERR
*                               OS_ERR_TMR_INVALID
*
* Returns    : none
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
void  OSTmrStop (OS_TMR  *ptmr,
                 INT8U    opt,
                 void    *callback_arg,
                 INT8U   *perr)
{
    OS_TMR_CALLBACK  pfnct;


#if OS_ARG_CHK_EN > 0
    if (perr == (INT8U *)0) {                               /* Validate arguments                                     */
        return;
    }
    if (ptmr == (OS_TMR *)0) {
        *perr = OS_ERR_TMR_INVALID;
        return;
    }
#endif
    OSTmr_Lock();
    OSTmr_Unlink(ptmr);                                     /* Remove from current wheel spoke                        */
    *perr = OS_NO_ERR;
    switch (opt) {
        case OS_TMR_OPT_CALLBACK:
             pfnct = ptmr->OSTmrCallback;                   /* Execute callback function if available ...             */
             if (pfnct != (OS_TMR_CALLBACK)0) {
                 (*pfnct)(ptmr, ptmr->OSTmrCallbackArg);    /* ... using the 'argument' specified @ timer start       */
             }
             break;

        case OS_TMR_OPT_CALLBACK_ARG:
             pfnct = ptmr->OSTmrCallback;                   /* Execute callback function if available ...             */
             if (pfnct != (OS_TMR_CALLBACK)0) {
                 (*pfnct)(ptmr, callback_arg);              /* ... using the 'callback_arg' provided in this function */
             }
             break;

        case OS_TMR_OPT_NONE:
             break;

        default:
            *perr = OS_ERR_TMR_INVALID_OPT;
            break;
    }
    OSTmr_Free(ptmr);                                       /* Return timer to free list of timers                    */
    OSTmr_Unlock();
    *perr = OS_NO_ERR;
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                      SIGNAL THAT IT'S TIME TO UPDATE THE TIMERS
*
* Description: This function is typically called by the ISR that occurs at the timer tick rate and is used to signal to
*              OSTmr_Task() that it's time to update the timers.
*
* Arguments  : none
*
* Returns    : none
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
void  OSTmrSignal (void)
{
    OSSemPost(OSTmrSemSignal);
}
#endif

/*$PAGE*/
/*
************************************************************************************************************************
*                                               ALLOCATE AND FREE A TIMER
*
* Description: This function is called to allocate a timer.
*
* Arguments  : none
*
* Returns    : a pointer to a timer if one is available
************************************************************************************************************************
*/

#if OS_TMR_EN > 0
static  OS_TMR  *OSTmr_Alloc (void)
{
    OS_TMR *ptmr;