请教freertos“重启”任务的问题

zqf441775525

如题，举例我有1个闪灯的任务，

while(1)
{
LED_ON;
vTaskDelay(1000);
LED_OFF;
vTaskDelay(1000);
}

还有个485任务，接收到特定的命令的时候想让这个闪灯任务“重启”，即：无论现在LED是ON还是OFF状态，无论现在的vTaskDelay到了500还是800，在这个485任务中要能够使这个闪灯任务从头开始，有没有什么好的办法？

我看了任务挂起，好像不适合这种用法，任务恢复之后还是从挂起点继续运行。
我想到一种解决办法，就是这个删除任务，再新建这个任务，但是这样做会不会产生内存碎片？

大神们有没有其他更好的办法？

墨非

退一步行吗？  
信号量 + 双while (1)   
检测到信号量就break第二层while(1)  弹到第一层while(1) 从头开始 ， 放小task delay 的颗粒度，LED闪烁延时用个变量自己计数呗。  响应“重启” 的滞后时间就是一个task的delay粒度。

yyts

freertos不知道，比如rt-thread可以用信号量。

while(1)
{
  LED_ON;
  获取信号量（超时时间1秒）
  if(获取到信号量)  continue；
  LED_OFF;
  获取信号量（超时时间1秒）
}

zzh90513

灯闪烁延时做成状态机，想怎么玩都行

zqf441775525

墨非 发表于 2019-8-29 23:25
退一步行吗？  
信号量 + 双while (1)   
检测到信号量就break第二层while(1)  弹到第一层while(1) 从头开 ...

这是一个办法，把delay1000改成10个delay100，在间隙里判断标志位

yangsen

按4楼说的，用信号量，在循环结束等信号量

zqf441775525

zzh90513 发表于 2019-8-30 00:13
灯闪烁延时做成状态机，想怎么玩都行

目前是有45个灯或者继电器，而且不完全是闪烁，是可编程的，用状态机太麻烦了，所以用的freer ‘tis 操作系统，跑了九十多个任务

abutter

3 楼做法是是比较简洁合理的，前提是有等待信号量超时机制。

dalige

zqf441775525 发表于 2019-8-30 08:55
目前是有45个灯或者继电器，而且不完全是闪烁，是可编程的，用状态机太麻烦了，所以用的freer ‘tis 操作 ...

90多个任务？
还是考虑下基于事件（信号）去设计逻辑吧。

zzh90513

zqf441775525 发表于 2019-8-30 08:55
目前是有45个灯或者继电器，而且不完全是闪烁，是可编程的，用状态机太麻烦了，所以用的freer ‘tis 操作 ...

1. 每个灯用一个结构体定义：

1. /*
   
2. * LED control structure
   
3. */
   
4. typedef struct
   
5. {
   
6.     uint8_t mode;    /* Operation mode */
   
7.     uint8_t todo;    /* Blink cycles left */
   
8.     uint8_t onPct;   /* On cycle percentage */
   
9.     uint16_t time;   /* On/Off cycle time(msec) */
   
10.     uint32_t next;   /* Time for next change */
    
11. 
    
12. }LedCtrl_t;

复制代码

2. 在freertos开一个定时器

1. /**
   
2. * @brief  Update leds to work with blink
   
3. * @param  None
   
4. * @retval None
   
5. */
   
6. void LedUpdate(void)
   
7. {
   
8.     uint8_t led;
   
9.     uint8_t pct = 10;
   
10.     uint8_t leds;
    
11.     LedCtrl_t *pledctrl;
    
12.     uint32_t time;
    
13.     uint16_t next;
    
14.     uint16_t wait;
    
15. 
    
16.     /* Check if sleep is active or not */
    
17.     if (sxLedObj.sleepAct)
    
18.     {
    
19.         return;
    
20.     }
    
21. 
    
22.     next = 0;
    
23.     led = 1;
    
24.     leds = LED_ALL;
    
25.     pledctrl = sxLedObj.ledCtrlTbl;
    
26. 
    
27.     while (leds)
    
28.     {
    
29.         if (!(leds & led))
    
30.         {
    
31.             led <<= 1;
    
32.             pledctrl++;
    
33.             continue;
    
34.         }
    
35. 
    
36.         if (!(pledctrl->mode & LED_MODE_BLINK))
    
37.         {
    
38.             leds ^= led;
    
39.             led <<= 1;
    
40.             pledctrl++;
    
41.             continue;
    
42.         }
    
43. 
    
44.         /* Get current system tick count(ms) */
    
45.         time = Led_GetSystemClock();
    
46. 
    
47.         if (time >= pledctrl->next)
    
48.         {
    
49.            if (pledctrl->mode & LED_MODE_ON)
    
50.            {
    
51.                pct = 100U - pledctrl->onPct;   /* Percentage of cycle for off */
    
52.                pledctrl->mode &= ~LED_MODE_ON; /* Say it's not on */
    
53.                LedOnOff(led, LED_MODE_OFF);    /* Turn it off */
    
54. 
    
55.                if (!(pledctrl->mode & LED_MODE_FLASH))
    
56.                {
    
57.                    pledctrl->todo--;  /* Not continuous, reduce count */
    
58.                }
    
59.            }
    
60.            else if ((!pledctrl->todo) && !(pledctrl->mode & LED_MODE_FLASH))
    
61.            {
    
62.                pledctrl->mode ^= LED_MODE_BLINK;  /* No more blinks */
    
63.            }
    
64.            else
    
65.            {
    
66.                pct = pledctrl->onPct;          /* Percentage of cycle for on */
    
67.                pledctrl->mode |= LED_MODE_ON;  /* Say it's on */
    
68.                LedOnOff(led, LED_MODE_ON);     /* Turn it on */
    
69.            }
    
70. 
    
71.            if (pledctrl->mode & LED_MODE_BLINK)
    
72.            {
    
73.                wait = (((uint32_t)pct * (uint32_t)pledctrl->time) / 100U);
    
74.                pledctrl->next = time + wait;
    
75.            }
    
76.            else
    
77.            {
    
78.                /* No more blink, No more wait */
    
79.                wait = 0;
    
80. 
    
81.                /* After blinking, set the LED back to the state before it blinks */
    
82.                LedSet(led, ((sucLedPreBlinkState & led) != 0U)? LED_MODE_ON : LED_MODE_OFF);
    
83. 
    
84.                /* Clear the saved bit */
    
85.                sucLedPreBlinkState &= led ^ 0xFF;
    
86.            }
    
87.         }
    
88.         else
    
89.         {
    
90.            wait = pledctrl->next - time;  /* Time left */
    
91.         }
    
92. 
    
93.         if (!next || (wait && (wait < next)))
    
94.         {
    
95.            next = wait;
    
96.         }
    
97. 
    
98.         leds ^= led;
    
99.         led <<= 1;
    
100.         pledctrl++;
     
101.     }
     
102. 
     
103.     if (next)
     
104.     {
     
105.        /* Start timer to schedule event */
     
106.        if (xTimerChangePeriod(shTmrLed,  pdMS_TO_TICKS(next), 0) != pdPASS)
     
107.        {
     
108.            xprintf("Led blink timer start failure!\r\n");
     
109.        }
     
110.     }
     
111. }

复制代码

3. 再写一个函数控制结构体变量，随时可以开启，关闭，控制闪烁次数，随时停止

niaojingxin

延时改为pend，消息触发，然后加if判断，continue.

zqf441775525

dalige 发表于 2019-8-30 10:06
90多个任务？
还是考虑下基于事件（信号）去设计逻辑吧。

其实我是在做密室逃脱的集中控制主板，45个输入，45个输出（继电器），每个输入触发可以设置最多3个输出，每个输出可以设置开的时间，关的时间，是否循环等设置的参数比较多。为了使程序逻辑简单些，就是每个输入和每个输出都是一个任务。再加上485等，总共大约90多个任务。

“基于事件（信号）”设计逻辑，是怎么样的思路呢？

liuqian

90多个任务，内核调度快累死了

zqf441775525

dalige 发表于 2019-8-30 10:06
90多个任务？
还是考虑下基于事件（信号）去设计逻辑吧。

45个继电器任务占用的堆栈大小是一样的，如果我删除一个继电器任务，再新建这个继电器任务，会产生内存碎片吗？有没有了解过FREERTOS的任务堆栈空间是怎么配置的？

zqf441775525

liuqian 发表于 2019-8-30 10:51
90多个任务，内核调度快累死了

还好吧，任务实时性要求不是太高，基本上是vtaskdelay（200）或者vtaskdelay（100）这样，每个任务执行时间很短，就是判断几个if语句。应该是留出足够的内核调度时间的。

zqf441775525

zzh90513 发表于 2019-8-30 10:14
1. 每个灯用一个结构体定义：

定时器中断，在中断里判断计时是否到了相应的时间。这种方法在裸机的时候比较常用。
按照您的程序，我这边45个继电器对应45个Led_GetSystemClock();，而且这45个时间的开始点都是完全独立的，由45个输入随时触发开始，想想就麻烦。

我先试试“删除任务”之后再“新建任务”的方法。

ordinary

多输入多输出，用cpld更好搞定

zzh90513

zqf441775525 发表于 2019-8-30 11:15
定时器中断，在中断里判断计时是否到了相应的时间。这种方法在裸机的时候比较常用。
按照您的程序，我这 ...

不是在定时器中断，是freertos的定时器任务，在任务内扫描45个对象数组的标志而已，我一直这样用；
可以随时改变某一个LED的开关状态，指定闪烁次数，一直闪烁，以及闪烁的占空比；
PS:频繁创建删除任务，一直在分配释放内存，对系统稳定性肯定有一定影响

zqf441775525

zzh90513 发表于 2019-8-30 14:01
不是在定时器中断，是freertos的定时器任务，在任务内扫描45个对象数组的标志而已，我一直这样用；
可以 ...

45个LED任务都是使用相同大小的堆栈空间，删除和重建任务也仅限于这45个LED的任务，应该不会对系统有太大的影响。删除完立马再重建上，因为可能还有别的输入点要触发这个LED任务。

dalige

你这做法类似于http server的多线程，实际上单线程处理就可以了。
否则假设你有200个输入输出，你咋控制？
我不认为输入检测和输出控制的实时性有多高，实际上，把数据结构的定义好，压根不用啥freertos就搞好了。

zqf441775525

dalige 发表于 2019-8-30 14:49
你这做法类似于http server的多线程，实际上单线程处理就可以了。
否则假设你有200个输入输出，你咋控制？
...

这个实时性要求确实不高，100mS - 200mS都无所谓的。
单线程肯定是能够处理的，TIM定时100mS，然后每100mS把这45个灯的状态处理一遍就OK了。
现在是程序已经写的差不多了，只差这一步了。如果放弃这个方案推倒重来，自己又心有不甘。唉