• uC/OS-II时间(OS_time)块


    /*
    *********************************************************************************************************
    *                                                uC/OS-II
    *                                          The Real-Time Kernel
    *                                             TIME MANAGEMENT
    *
    *                          (c) Copyright 1992-2002, Jean J. Labrosse, Weston, FL
    *                                           All Rights Reserved
    *
    * File : OS_TIME.C
    * By   : Jean J. Labrosse
    *********************************************************************************************************
    */

    #ifndef  OS_MASTER_FILE
    #include "includes.h"
    #endif

    /*
    *********************************************************************************************************
    *                                DELAY TASK 'n' TICKS   (n from 0 to 65535)
    *
    * Description: This function is called to delay execution of the currently running task until the
    *              specified number of system ticks expires(到期).  This, of course, directly equates to delaying
    *              the current task for some time to expire.  No delay will result If the specified delay is
    *              0.  If the specified delay is greater than 0 then, a context switch will result.
    *
    * Arguments  : ticks     is the time delay that the task will be suspended in number of clock 'ticks'.
    *                        Note that by specifying 0, the task will not be delayed.
    *
    * Returns    : none
    *********************************************************************************************************
    */
    //延时时间
    void  OSTimeDly (INT16U ticks)
    {
    #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
        OS_CPU_SR  cpu_sr;
    #endif    

        if (ticks > 0) {                                                      /* 0 means no delay!         */
            OS_ENTER_CRITICAL();
            //Delay current task
            if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {  /* Delay current task        */
                //取消当前的任务状态
                OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
            }
            //延时的节拍数存到任务控制块中
            OSTCBCur->OSTCBDly = ticks;                                       /* Load ticks in TCB         */
            OS_EXIT_CRITICAL();
            //触发一次任务调度
            OS_Sched();                                                       /* Find next task to run!    */
        }
    }
    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                     DELAY TASK FOR SPECIFIED TIME
    *
    * Description: This function is called to delay execution of the currently running task until some time
    *              expires.  This call allows you to specify the delay time in HOURS, MINUTES, SECONDS and
    *              MILLISECONDS instead of ticks.
    *
    * Arguments  : hours     specifies the number of hours that the task will be delayed (max. is 255)
    *              minutes   specifies the number of minutes (max. 59)
    *              seconds   specifies the number of seconds (max. 59)
    *              milli     specifies the number of milliseconds (max. 999)
    *
    * Returns    : OS_NO_ERR
    *              OS_TIME_INVALID_MINUTES
    *              OS_TIME_INVALID_SECONDS
    *              OS_TIME_INVALID_MS
    *              OS_TIME_ZERO_DLY
    *
    * Note(s)    : The resolution on the milliseconds depends on the tick rate.  For example, you can't do
    *              a 10 mS delay if the ticker interrupts every 100 mS.  In this case, the delay would be
    *              set to 0.  The actual delay is rounded to the nearest tick.
    *********************************************************************************************************
    */
    //也是延时函数
    #if OS_TIME_DLY_HMSM_EN > 0
    INT8U  OSTimeDlyHMSM (INT8U hours, INT8U minutes, INT8U seconds, INT16U milli)
    {
        INT32U ticks;
        INT16U loops;


        if (hours > 0 || minutes > 0 || seconds > 0 || milli > 0) {
            if (minutes > 59) {
                return (OS_TIME_INVALID_MINUTES);    /* Validate arguments to be within range              */
            }
            if (seconds > 59) {
                return (OS_TIME_INVALID_SECONDS);
            }
            if (milli > 999) {
                return (OS_TIME_INVALID_MILLI);
            }
                                                     /* Compute the total number of clock ticks required.. */
                                                     /* .. (rounded to the nearest tick)                   */
            ticks = ((INT32U)hours * 3600L + (INT32U)minutes * 60L + (INT32U)seconds) * OS_TICKS_PER_SEC
                  + OS_TICKS_PER_SEC * ((INT32U)milli + 500L / OS_TICKS_PER_SEC) / 1000L;
            loops = (INT16U)(ticks / 65536L);        /* Compute the integral number of 65536 tick delays   */
            ticks = ticks % 65536L;                  /* Obtain  the fractional number of ticks             */
            OSTimeDly((INT16U)ticks);
            while (loops > 0) {
                OSTimeDly(32768);
                OSTimeDly(32768);
                loops--;
            }
            return (OS_NO_ERR);
        }
        return (OS_TIME_ZERO_DLY);
    }
    #endif
    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                         RESUME A DELAYED TASK
    *
    * Description: This function is used resume a task that has been delayed through a call to either
    *              OSTimeDly() or OSTimeDlyHMSM().  Note that you MUST NOT call this function to resume a
    *              task that is waiting for an event with timeout.  This situation would make the task look
    *              like a timeout occurred (unless you desire this effect).  Also, you cannot resume a task
    *              that has called OSTimeDlyHMSM() with a combined time that exceeds 65535 clock ticks.  In
    *              other words, if the clock tick runs at 100 Hz then, you will not be able to resume a
    *              delayed task that called OSTimeDlyHMSM(0, 10, 55, 350) or higher.
    *
    *                  (10 Minutes * 60 + 55 Seconds + 0.35) * 100 ticks/second.
    *
    * Arguments  : prio      specifies the priority of the task to resume
    *
    * Returns    : OS_NO_ERR                 Task has been resumed
    *              OS_PRIO_INVALID           if the priority you specify is higher that the maximum allowed
    *                                        (i.e. >= OS_LOWEST_PRIO)
    *              OS_TIME_NOT_DLY           Task is not waiting for time to expire
    *              OS_TASK_NOT_EXIST         The desired task has not been created
    *********************************************************************************************************
    */
    //This function is used resume a task that has been delayed through a call to either OSTimeDly() or OSTimeDlyHMSM()
    #if OS_TIME_DLY_RESUME_EN > 0
    INT8U  OSTimeDlyResume (INT8U prio)
    {
    #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
        OS_CPU_SR  cpu_sr;
    #endif    
        OS_TCB    *ptcb;

        //判断
        if (prio >= OS_LOWEST_PRIO) {
            return (OS_PRIO_INVALID);
        }
        OS_ENTER_CRITICAL();
        ptcb = (OS_TCB *)OSTCBPrioTbl[prio];                   /* Make sure that task exist                */
        //确定任务存在
        if (ptcb != (OS_TCB *)0) {
            //See if task is delayed
            if (ptcb->OSTCBDly != 0) {                         /* See if task is delayed                   */
                //Clear the time delay      
                ptcb->OSTCBDly  = 0;                           /* Clear the time delay                     */
                // See if task is ready to run
                if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* See if task is ready to run  */
                    OSRdyGrp               |= ptcb->OSTCBBitY;             /* Make task ready to run       */
                    OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
                    OS_EXIT_CRITICAL();
                    //task sched
                    OS_Sched();                                /* See if this is new highest priority      */
                } else {
                    OS_EXIT_CRITICAL();                        /* Task may be suspended                    */
                }
                return (OS_NO_ERR);
            } else {
                OS_EXIT_CRITICAL();
                return (OS_TIME_NOT_DLY);                      /* Indicate that task was not delayed       */
            }
        }
        OS_EXIT_CRITICAL();
        return (OS_TASK_NOT_EXIST);                            /* The task does not exist                  */
    }
    #endif    
    /*$PAGE*/
    /*
    *********************************************************************************************************
    *                                         GET CURRENT SYSTEM TIME
    *
    * Description: This function is used by your application to obtain the current value of the 32-bit
    *              counter which keeps track of the number of clock ticks.
    *
    * Arguments  : none
    *
    * Returns    : The current value of OSTime
    *********************************************************************************************************
    */

    #if OS_TIME_GET_SET_EN > 0
    INT32U  OSTimeGet (void)
    {
    #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
        OS_CPU_SR  cpu_sr;
    #endif    
        INT32U     ticks;


        OS_ENTER_CRITICAL();
        ticks = OSTime;        //The current value of OSTime
        OS_EXIT_CRITICAL();
        return (ticks);
    }
    #endif    

    /*
    *********************************************************************************************************
    *                                            SET SYSTEM CLOCK
    *
    * Description: This function sets the 32-bit counter which keeps track of the number of clock ticks.
    *
    * Arguments  : ticks      specifies the new value that OSTime needs to take.
    *
    * Returns    : none
    *********************************************************************************************************
    */

    #if OS_TIME_GET_SET_EN > 0
    void  OSTimeSet (INT32U ticks)
    {
    #if OS_CRITICAL_METHOD == 3                      /* Allocate storage for CPU status register           */
        OS_CPU_SR  cpu_sr;
    #endif    


        OS_ENTER_CRITICAL();
        OSTime = ticks;
        OS_EXIT_CRITICAL();
    }
    #endif    

  • 相关阅读:
    在Visual Studio中使用NUnit
    C#调用Exe
    网页用chrome打开为乱码
    ctags最基本用法
    Facebook Connect
    SVM初体验
    python中可恶的回车符
    初识PowerDesigner
    Mysql中文乱码问题解决
    stat函数
  • 原文地址:https://www.cnblogs.com/wxb20/p/6230851.html
Copyright © 2020-2023  润新知