ThreadX内核只有相对延迟函数tx_thread_sleep，没有绝对延迟函数，这里简单实现一个tx_thread_sleepuntil

eric2013

条件：
1、有一个bsp_KeyScan函数，这个函数处理时间大概耗时2ms。
2、有两个任务，一个任务Task1是用的tx_thread_sleep延迟，延迟10ms，另一个任务Task2是用的tx_thread_sleepuntil（ThreadX没有这个函数，要自己封装）延迟，延迟10ms。不考虑任务被抢占而造成的影响。

相对性的含义：
bsp_KeyScan+  tx_thread_sleep(10)  --->   bsp_KeyScan +  tx_thread_sleep (10)  
|----2ms + 10ms 为一个周期------|              |----2ms + 10ms 为一个周期----|

周期性延迟含义：
bsp_KeyScan + tx_thread_sleepunti                   ------>  bsp_KeyScan + tx_thread_sleepunti
|----10ms为一个周期（2ms包含在10ms内）---|              |------10ms 为一个周期---------------|

这里我们通过tx_thread_sleep来实现一个tx_thread_sleepuntil

1. static void AppTaskMsgPro(ULONG thread_input)
   
2. {
   
3.         UINT Delay, NextTime;
   
4.         const UINT Frequency = 200;
   
5.         
   
6.         /* 获取xFrequency个时钟节拍后的时间 */
   
7.         NextTime = tx_time_get() + Frequency;
   
8.         
   
9.     while(1)
   
10.     {
    
11.                 bsp_LedToggle(3);
    
12.                
    
13.                 Delay = NextTime - tx_time_get();
    
14.                 NextTime += Frequency;
    
15.                
    
16.                 if(Delay <= Frequency)
    
17.                 {
    
18.                         tx_thread_sleep(Delay);
    
19.                 }
    
20.         }
    
21. }

复制代码

avalons

正看教程学到这一章，这样是否可以消除被任务抢占的影响呢？

[C] 纯文本查看 复制代码

static void AppTaskMsgPro(ULONG thread_input)
{
    UINT Delay, NextTime;
    const UINT Frequency = 200;

    /* 获取 Frequency 个时钟节拍后的时间 */
    NextTime = tx_time_get() + Frequency;

    while (1)
    {
         /* 运行任务程序 */
        bsp_LedToggle(3);

        /* 计算与周期边界值的差 */
        Delay = NextTime - tx_time_get();

        /* 获取下一次周期的边界值 */
        if(Delay > 100000)   /* 若差值计算为负值，UINT类型的数值会是一个很大的正数 */
            NextTime = tx_time_get()+Frequency;
        else
            NextTime += Frequency;

        /* 延时到边界值 */
        if (Delay <= Frequency)
        {
            tx_thread_sleep(Delay);
        }
    }
}