FreeRTOS的Tickless和STM32的STOP结合实现嵌入式低功耗

10xjzheng

首先我们先来看下结果，如下图所示，我建立了两个LED翻转的任务，一个是200ms间隔，一个是500ms间隔，如第一二个波形所示，
第三波形如果是高电平，则处于STOP模式，如果是低电平，则处于run模式。

将波形进行放大，可以看到芯片及时地在任务1、2执行之前进行翻转。

首先我们来讨论下嵌入式系统的低功耗，简单地思路是干完活进入空闲任务的时候进入，然后醒来查看是否有任务需要执行，没有的话就继续进入空闲任务，这样子看来看来似乎还是可以的。
下面我们来看一个案例，只有一个任务，运行频率时1Hz，下面中我们可以看到在这1s内CPU不断地醒来，睡去，那么我们不禁回想，
既然已经知道任务地执行频率时1Hz，为什么还要频繁地查询？频繁地查询其实是很耗时的，因为进入和退出都需要一定的时间。


因此Tickless应运而生，在操作系统的管理之下，计算下一次应该醒来的准确时间，以实现长而少的睡眠-唤醒，而不是跟着tick的频
率无谓地醒来检查。正如我放上来的第一张图，可以看到需要翻转的时候，CPU就醒来才进行翻转。
接着我们需要结合CPU的低功耗模式来看看那种模式比较合适。

有三种模式，这三种模式工作的单元越来越少，而功耗也越来越低，首先standby不符合我的系统，醒来相当于复位。sleep和stop的
主要区别是stop模式下HSI、HSE时钟也会被关掉（这就是为什么系统醒来之后会好像慢了一样），stop模式的功耗也更低，粗略测
试时几mA，关掉HSI、HSE对我的系统没有什么影响，最多醒来的时候再配置一下。但是唤醒源不能再是任何的时钟了，只能是
EXTI Line，包括了RTC wake up定时器，于是我得首先将systick转变成RTC wake up timer，让它来担任其系统心跳的职责，修改的
步骤如下。
freeRTOS官方已经意识到担任心跳的定时器有可能限制于低功耗、在tickless模式溢出等因素不能进行工作，因此有文章介绍了怎么
修改为别的定时器来担任这个职责。
http://www.freertos.org/low-power-ARM-cortex-rtos.html
主要分为几个步骤：
1.配置新的定时器，然后将其覆盖掉其中的定时器配置。这里面有个很重要的点，将定时器的优先级配置为最低，至于为什么，见Cortex-M3中的图。

1. #if configOVERRIDE_DEFAULT_TICK_CONFIGURATION == 0
   
2. 
   
3.         void vPortSetupTimerInterrupt( void )
   
4.         {
   
5.                 /* Calculate the constants required to configure the tick interrupt. */
   
6.                 #if configUSE_TICKLESS_IDLE == 1
   
7.                 {
   
8.                         ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
   
9.                         xMaximumPossibleSuppressedTicks = (portMAX_16_BIT_NUMBER+1) / ulTimerCountsForOneTick;
   
10. //                        ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
    
11.       ulStoppedTimerCompensation=0;
    
12.                 }
    
13.                 #endif /* configUSE_TICKLESS_IDLE */
    
14. 
    
15.                 /* Configure RTC to interrupt at the requested rate. */
    
16.                 RTC_Config();
    
17. //                portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
    
18. //                portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
    
19.         }
    
20. 
    
21. #endif /* configOVERRIDE_DEFAULT_TICK_CONFIGURATION */

复制代码

2.删除掉Systick中断函数调用的osSystickHandler();，给RTC的wake up 定时器中断。
接着我们就要开始配置tickless模式了。
1.首先将configUSE_TICKLESS_IDLE这个宏置1 or 2，1表示使用systick，2表示使用另外的定时器。
这个宏为1，则使用官方在port.c中的移植。
这个宏为2，可以使用自己的一些移植。
实际上我是使能为1，使用非systick中断，但是对应修改官方移植好的函数。
2.配置下面几个宏

这个宏是你定时器计数的频率，我的RTC配置为2KHz，所以这里配置为2000
#define configCPU_CLOCK_HZ                        ( 2000 )
这个宏是心跳的频率，我设置为1000
#define configTICK_RATE_HZ                        ( ( TickType_t ) 1000 )
这几个设置的作用见前面的函数vPortSetupTimerInterrupt，这个函数中间还有变量ulStoppedTimerCompensation，这个变量是在
配置tickless的过程中暂时关掉定时器需要设置的偏移，至于多少要用逻辑分析仪测试一下，然后配置下就可以，上面直接配置为0。

2.修改函数vPortSuppressTicksAndSleep，这个函数就是系统调用进入stop模式之前的配置，这里涉及到一些定时器最大可以定时
的时间等等参数的配合。这个函数有一个参数，这个参数表示要延时的tick数，函数中我们可以将其转化为定时器要延时的时间个数。
这个函数在系统的管理之下，只有满足两个条件才运行。
1.首先所有的任务都是挂起或者阻塞的状态。
2.下一次系统应该醒来的时间应该大于configEXPECTED_IDLE_TIME_BEFORE_SLEEP，这个宏是用户可以定义的，默认配置为2。

1. /*-----------------------------------------------------------*/
   
2. 
   
3. #if configUSE_TICKLESS_IDLE == 1
   
4.         __weak void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
   
5.         {
   
6.         uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickCTRL;
   
7.         TickType_t xModifiableIdleTime;
   
8.   uint32_t i,j;
   
9.                 /* 确保计算出来的不会超过xMaximumPossibleSuppressedTicks */
   
10.                 if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
    
11.                 {
    
12.                         xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
    
13.                 }
    
14.                
    
15.     //计算定时器需要重装的值
    
16.                 ulReloadValue =  ( ulTimerCountsForOneTick * xExpectedIdleTime );
    
17.                
    
18.                 //允许减去一些偏移，ulStoppedTimerCompensation在函数vPortSetupTimerInterrupt中可以进行配置
    
19.           //可以通过逻辑分析仪测量，单位跟定时器是一样的
    
20.                 if( ulReloadValue > ulStoppedTimerCompensation )
    
21.                 {
    
22.                         ulReloadValue -= ulStoppedTimerCompensation;
    
23.                 }
    
24. 
    
25.     /* 暂时关闭掉RTC定时器，配置RTC，这会导致系统时钟的一些漂移*/
    
26.     RTC_WakeUpCmd(DISABLE);
    
27. 
    
28.                 //进入临界段
    
29.                 __disable_irq();
    
30. 
    
31.                 //最后检查下是否可以进入低功耗模式，因为有可能在这个配置过程中发生中断，导致某些任务就绪等等
    
32.                 if( eTaskConfirmSleepModeStatus() == eAbortSleep )
    
33.                 {
    
34.       //将RTC配置为原来的配置
    
35.                         RTC_SetWakeUpCounter(ulTimerCountsForOneTick-1);
    
36.                        
    
37.                         //使能RTC
    
38.                         RTC_WakeUpCmd(ENABLE);
    
39. 
    
40.                         //退出临界段
    
41.                         __enable_irq();
    
42.                 }
    
43.                 else
    
44.                 {
    
45.       //重装值为前面计算好的
    
46.       RTC_SetWakeUpCounter(ulReloadValue);
    
47. 
    
48.                         //使能RTC定时器
    
49.                         RTC_WakeUpCmd(ENABLE);
    
50. 
    
51.                         xModifiableIdleTime = xExpectedIdleTime;
    
52.                        
    
53.                         //进入低功耗之前需要做的配置，比如关闭外设时钟
    
54.                         configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
    
55.                        
    
56.                         if( xModifiableIdleTime > 0 )
    
57.                         {
    
58.                                 __dsb( portSY_FULL_READ_WRITE );
    
59.                                 //进入低功耗stop模式，在这里插入CPU进入低功耗的语句
    
60.                                 PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
    
61. //                                __isb( portSY_FULL_READ_WRITE );
    
62.                         }
    
63. 
    
64.                         //退出低功耗模式应该做的事情
    
65.                         configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
    
66. 
    
67.                         //重新使能中断
    
68.                         __enable_irq();
    
69.                         //没有这个延时RTCWakeupFlag居然为0，我操，不知道为什么
    
70.       for(i=0;i<5;i++);
    
71.                         printf("44:%d-\r\n",RTCWakeupFlag);
    
72. 
    
73.                         //看下是不是tick中断到期，因为其他的中断也是可以唤醒CPU，执行到这里来的，计算重载值
    
74.                         if( RTCWakeupFlag==SET )
    
75.                         {
    
76.                                 uint32_t ulCalculatedLoadValue;
    
77.                        
    
78. //                                Uart_Sendbyte1('A');
    
79. 
    
80.                                 //这里省略精确的计算
    
81. //                                //精确计算下一个需要延时的时间，一个tick需要延时的时间减去从长延时恢复之后到现在一共过了的时间
    
82. //                                ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
    
83. //                                //计算出来的越界了，可能是因为函数configPOST_SLEEP_PROCESSING运行太久了！
    
84. //                                if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
    
85. //                                {
    
86. //                                        ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
    
87. //                                }
    
88. 
    
89.                                 //计算修正的值
    
90.                                 ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
    
91.                         }
    
92.                         else  //不是tick中断，其他的中断
    
93.                         {
    
94. //                                Uart_Sendbyte1('B');
    
95.                                
    
96.                                 //已经完成的定时器计数
    
97. //                                ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - RTC_GetWakeUpCounter();
    
98. 
    
99.                                 //计算已经完成的延时的tick数，偏少
    
100. //                                ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
     
101.                                
     
102.                                 //这个是错误的，由于RTC没有
     
103.                                 ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
     
104. 
     
105. //                                //小数部分
     
106. //                                portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1 ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
     
107.                         }
     
108.                         printf("55:%d-\r\n",RTCWakeupFlag);
     
109.                         //最后把计算值重装到寄存器
     
110.                         RTC_SetWakeUpCounter( ulTimerCountsForOneTick - 1UL );
     
111. 
     
112.                         portENTER_CRITICAL();
     
113.                         {
     
114.                                 //修正Tick计数
     
115.                                 vTaskStepTick( ulCompleteTickPeriods );
     
116.                         }
     
117.                         portEXIT_CRITICAL();
     
118.                 }
     
119.         }
     
120. 
     
121. #endif /* #if configUSE_TICKLESS_IDLE */

复制代码

不足：
由于唤醒定时器位数是有限的，可能有的时候tickless要延时很久，而定时器无法延时比较久的时间。
这个当然是通过分次睡眠唤醒来解决咯。

问题：
如果只有tick中断还好，如果是其他的中断让CPU醒来呢？这个时候该怎么处理？
portSUPPRESS_TICKS_AND_SLEEP是在空闲任务中被调用的，发生外部中断之后，首先会执行中断服务函数，中断服务函数运行过
程中如果没有任务就绪的话，那么很简单，程序会回到进入睡眠的那个地方，在空闲任务中，又重新执行vPortSuppressTicksAndSleep
进入睡眠模式。在外部中断中也有可能有一些任务会被就绪，中断出来之后会先进行任务切换到高优先级任务，等到所有的任务都执行
完毕了，就进入空闲任务中，也就是我们之前进入睡眠模式的那个地方，空闲任务又重新执行了函数vPortSuppressTicksAndSleep进入
tickless。CPU执行了一大圈才回到进入到空闲任务中的睡眠模式的那个点，貌似没有问题。有几个小细节不知道大家有没有注意到，我
们的tick计数值还没有更新，tick定时器也没有重新配置，唤醒之后需要配置外设启动那些也没有做。因为之前我们假设了从哪里休眠就
从哪里唤醒，但是这次不是这样子的！这是需要注意的点，我现在想到的解决办法就是不在中断中让任务就绪。你可能会说，那延时的
那些任务不是也会影响到吗？no，no，no！如果没有进入休眠之前的那个点，那么tick数还没有更新呢。由tick管理的这些任务包括软
件定时器的回调函数那些都不会被就绪的，所以这个是没有问题的。


问题：
下面这两个在进入休眠的前后是干什么的呢？
__dsb( portSY_FULL_READ_WRITE );
__isb( portSY_FULL_READ_WRITE );
见下面网友回复。

问题：
宏configPRE_SLEEP_PROCESSING、configPOST_SLEEP_PROCESSING给的参数xModifiableIdleTime是干什么的呢？
见下面网友回复。

tickless的一些资料：
http://mcuoneclipse.com/2013/07/06/low-power-with-freertos-tickless-idle-mode/
http://www.freertos.org/low-power-ARM-cortex-rtos.html
http://www.freertos.org/low-power-tickless-rtos.html

aozima

首先，得找一个适合的低功耗定时器，且是脱离CPU可以独立运行的。

inkfish321

这个我也正准备搞。之前用这种方式在没RTOS的情况下也用上了。这次准备用FREERTOS现成的。

security

aozima 发表于 2015-9-28 09:19
首先，得找一个适合的低功耗定时器，且是脱离CPU可以独立运行的。

是的，如果想达到最佳的低功耗，必须具备一个 异步定时器，即在任何low power模式下，都可以运行的定时器，用来唤醒。
为什么SysTick无法胜任呢？
一般来说，如果直接依赖于SysTick定时器的话，对于ARM cortex-m系列，功耗无法到最低，
因为ARM一旦进入内核的最低功耗时，SysTick定时器是停止的，无法唤醒。

但我们仍可以继续以SysTick作为OS的时钟基准定时器，仅在必要时，才启用异步定时器
而不用直接舍弃SysTick定时器。
（在进入Tickless时，暂停SysTick，启动异步定时器，进入睡眠，唤醒后，再重新开启SysTick定时）

zhonghua_li

最主要的还是vPortSuppressTicksAndSleep这个函数。
要注意 有种情况可能会让低功耗定时器提前醒来（如，外部中断）

aozima

zhonghua_li 发表于 2015-9-28 15:00
最主要的还是vPortSuppressTicksAndSleep这个函数。
要注意 有种情况可能会让低功耗定时器提前醒来（如，外 ...

tick补偿是必须的

10xjzheng

The embOS tickless low power support reduces the power consumption for e.g. battery powered devices. Instead of having a timer interrupt for each system tick the timer is reprogrammed to be able to spend as much time as possible in low power mode.
https://www.segger.com/tickless-support.html

shotstar

谢谢分享，写的很详细，可以研究一下。

security

1、由于唤醒定时器位数是有限的，可能有的时候tickless要延时很久，而定时器无法延时比较久的时间。
-----------------------------------------------------------------------------------------------------------------------------------------
- 这个每次要进入sleep时，需要计算本次睡眠的时间，如果超过定时器的上限，则只睡眠定时器的时间。
- 唤醒后，如果没有其他事件的话，则重新再进入tilkless，类似于传统意义上的：数据包过长就要分包处理的机制一样。
- 依次循环，直到指定的睡眠时间耗尽，因此，这个不是问题。

2、问题：如果只有tick中断还好，如果是其他的中断让CPU醒来呢？这个时候该怎么处理
-----------------------------------------------------------------------------------------------------------------------------------------
- 我们需要处理两种唤醒情况，一种是异步定时器的唤醒，或者被其他中断唤醒（此时异步定时器必然未计数到位）
- 唤醒时，都需要做tick的同步，即将此次睡眠流逝的时间，转换为tick值，累加到OS的tick里面去
- 对于异步定时器事件，睡眠流逝的时间值就是我们设置的睡眠值
- 对于其他中断事件，说明异步定时器还未计数到位，此时，睡眠流逝的时间值就是异步定时器当前cnt值（假设cnt从0值开始）

security

问题：
下面这两个在进入休眠的前后是干什么的呢？
__dsb( portSY_FULL_READ_WRITE );
__isb( portSY_FULL_READ_WRITE );
尚未清楚。
-----------------------------------------------------------------------------------------------------------------------------------------
- 关于DSB和ISB，这两条命令你可以去看看权威指南
- 不过在这边的话，更重要的是休眠前的DSB，这个用于确保WFI执行前，所有的存储器访问动作（可能有缓存动作，即buffered write），都已经被真正completed，才进入休眠
- 这点典型如，进行休眠前，可能设置一些系统电源寄存器，我们要确保这些操作是完成的，如果不通过DSB，我们只好自己手动挡，写入之后，再去执行一次读取动作（当然要是volatile），手动确保写入是completed的
- ISB是清除指令流水线，确保指令的一致性，用在这边，其实可有可无。

问题：
宏configPRE_SLEEP_PROCESSING、configPOST_SLEEP_PROCESSING给的参数xModifiableIdleTime是干什么的呢？
尚未清楚。
-----------------------------------------------------------------------------------------------------------------------------------------
- 我这边没有FreeRTOS的官方原始版本，木有发现此宏的调用，不过还是特意去看了下原始版本，发现注释如下：

/* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
   set its parameter to 0 to indicate that its implementation contains
   its own wait for interrupt or wait for event instruction, and so wfi
   should not be executed again.  However, the original expected idle
   time variable must remain unmodified, so a copy is taken. */
   xModifiableIdleTime = xExpectedIdleTime;
   configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
   if( xModifiableIdleTime > 0 )
   {
                   __dsb( portSY_FULL_READ_WRITE );
                   __wfi();
                   __isb( portSY_FULL_READ_WRITE );
   }
   configPOST_SLEEP_PROCESSING( xExpectedIdleTime );

- 你仔细看看前面的描述，就是说configPRE_SLEEP_PROCESSING宏，必然是一个简单的宏，而不会是函数宏
- configPRE_SLEEP_PROCESSING会改变参数的值，也就是这里的xModifiableIdleTime
- 当xModifiableIdleTime被设置为0值时，说明configPRE_SLEEP_PROCESSING自行实现了休眠的动作
- 此时接下去的分支，就不会执行（那是默认的休眠动作）
- 至此，你应该明白了。

10xjzheng

security 发表于 2015-9-28 17:50
1、由于唤醒定时器位数是有限的，可能有的时候tickless要延时很久，而定时器无法延时比较久的时间。
------ ...

早上发现RTC居然没有计数值的一个寄存器喔，只有重载值的，这样子怎么解决外部中断来更新tick的问题？

security

10xjzheng 发表于 2015-9-29 11:40
早上发现RTC居然没有计数值的一个寄存器喔，只有重载值的，这样子怎么解决外部中断来更新tick的问题？ ...

我这边也只讲机制，不细化策略
总之一句话，就是要想办法计算出本次实际睡眠的时间，更新到tick里面去。

374184600

看着好高端啊！

10xjzheng

楼主位下面的程序部分改为如下所示。这样子改的原因是RTC没有计数值可以读取，为什么判断一个引脚的状态，这个引脚在进入休眠之前改为低，RTC中断之后改为高，因为变量作为标志位来判断RTC中断中置位了还是没有变化，不知道为什么，就用一个管脚来代替。这样子如果不是RTC中断，那么程序会一直等待到下一个RTC中断才继续执行！如果产生非RTC中断就会浪费了一些CPU不该运行时间，但是没有办法，RTC没有计数值可以读取。

1. //                        //没有这个延时RTCWakeupFlag居然为0，我操，不知道为什么
   
2. //      for(i=0;i<5;i++);
   
3.                        
   
4.       while(GPIO_ReadOutputDataBit(RTC_FLAG_PORT,RTC_FLAG_PIN)!=SET);
   
5.                        
   
6.       ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
   
7.                        
   
8.                        
   
9. //                        //看下是不是tick中断到期，因为其他的中断也是可以唤醒CPU，执行到这里来的，计算重载值
   
10. //                        if( RTCWakeupFlag==SET )
    
11. //                        {
    
12. //                                uint32_t ulCalculatedLoadValue;
    
13. //                       
    
14. //                                Uart_Sendbyte1('A');
    
15. 
    
16. //                                //这里省略精确的计算
    
17. ////                                //精确计算下一个需要延时的时间，一个tick需要延时的时间减去从长延时恢复之后到现在一共过了的时间
    
18. ////                                ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
    
19. ////                                //计算出来的越界了，可能是因为函数configPOST_SLEEP_PROCESSING运行太久了！
    
20. ////                                if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
    
21. ////                                {
    
22. ////                                        ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
    
23. ////                                }
    
24. 
    
25. //                                //计算修正的值
    
26. //                                ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
    
27. //                        }
    
28. //                        else  //不是tick中断，其他的中断
    
29. //                        {
    
30. //                                Uart_Sendbyte1('B');
    
31. //                               
    
32. //                                //已经完成的定时器计数
    
33. ////                                ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - RTC_GetWakeUpCounter();
    
34. 
    
35. ////                                //计算已经完成的延时的tick数，偏少
    
36. ////                                ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
    
37. 
    
38. //                                //这个是错误的，由于RTC没有
    
39. //                                ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
    
40. 
    
41. ////                                //小数部分
    
42. ////                                portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1 ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
    
43. //                        }
    
44. 
    
45. 
    
46.                         //最后把计算值重装到寄存器
    
47.                         RTC_SetWakeUpCounter( ulTimerCountsForOneTick - 1UL );
    

复制代码

10xjzheng

思考了一天，算是暂时比较好地解决了这个问题。
arm和ST真的是没有诚意啊，arm搞个systick给操作系统却没有想到操作系统为了低功耗要求在低功耗模式下也可以运行，ST搞个RTC wake up timer却没有计数值，那让我们高tickless的怎么弄嘛！另外分频又是够坑爹，怎么分频出1000KHz这些！

Excellence

security

10xjzheng 发表于 2015-9-29 23:18
思考了一天，算是暂时比较好地解决了这个问题。
arm和ST真的是没有诚意啊，arm搞个systick给操作系统却没有 ...

看LZ位的回答
-----------------------------------------------------------------------------------------------------------------------------------------
问题：
如果只有tick中断还好，如果是其他的中断让CPU醒来呢？这个时候该怎么处理？
-----------------------------------------------------------------------------------------------------------------------------------------
我自己是看晕掉了。

结合后续的改动，我就不明真相的说几点吧：
- 你将方案限制为ISR不允许任务就绪，这是不可取的，举个栗子，这个中断如果是紧急事件，触发一个semaphore之类的，
  这会拉低整个系统的实时性。

- STM32系列我没接触过，我粗略看了下F4的手册，对于RTC唤醒计数器寄存器貌似是可以读取的，当然我只是纸上谈兵
- 如果没有直接的计数器，通过前后RTC时间，也是可以算出的
- 如果这些都无法达标的话，那么你可能就要考虑不启用STOP模式，而是启用SLEEP模式
- SysTick在SLEEP模式下，应该能正常工作的，只是在ARM内核的DEEPSLEEP才无法工作。

总之，tickless是我们人为加上去的，程序的效果对外表现，要做到，逼近跟没有tickless一样，这样tickless才可以落地：
- 在任务idle时，进入idle线程处理
- 外部异步事件发生，如果使得高优先级任务就绪，就应抢占idle线程
- 没有外部异步事件，而是task_sleep耗尽，也会抢占idle线程，执行对应的线程

10xjzheng

Excellence 发表于 2015-9-30 08:59

霸气，论坛元老了！

10xjzheng

security 发表于 2015-9-30 10:16
看LZ位的回答
------------------------------------------------------------------------------------- ...

1.拉低系统的实时性是会的，我只能期望没有中断，但是现在也没有什么解决的办法，要么只能不用tickless了。
2.“RTC唤醒计数器寄存器貌似是可以读取的”，你可不可以稍微说下思路？我很仔细地翻了手册，还是发现不了好的思路。
3.将stop模式改为sleep模式也是一种思路，这样子systick就可以用了，但是功耗还不是很完美，毕竟stop才是更低，粗率测试好像是几mA。这种可能才是更好的办法，在功耗和实时性之间做一个平衡。

security

10xjzheng 发表于 2015-9-30 10:33
1.拉低系统的实时性是会的，我只能期望没有中断，但是现在也没有什么解决的办法，要么只能不用tickless了 ...

以下免责，我没接触过STM32

1. /**
   
2.   * @brief  Configures the RTC Wakeup counter.
   
3.   * @note   The RTC WakeUp counter can only be written when the RTC WakeUp
   
4.   *         is disabled (Use the RTC_WakeUpCmd(DISABLE)).        
   
5.   * @param  RTC_WakeUpCounter: specifies the WakeUp counter.
   
6.   *          This parameter can be a value from 0x0000 to 0xFFFF.
   
7.   * @retval None
   
8.   */
   
9. void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter)
   
10. {
    
11.   /* Check the parameters */
    
12.   assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter));
    
13.   
    
14.   /* Disable the write protection for RTC registers */
    
15.   RTC->WPR = 0xCA;
    
16.   RTC->WPR = 0x53;
    
17.   
    
18.   /* Configure the Wakeup Timer counter */
    
19.   RTC->WUTR = (uint32_t)RTC_WakeUpCounter;
    
20.   
    
21.   /* Enable the write protection for RTC registers */
    
22.   RTC->WPR = 0xFF;
    
23. }
    
24. 
    
25. /**
    
26.   * @brief  Returns the RTC WakeUp timer counter value.
    
27.   * @param  None
    
28.   * @retval The RTC WakeUp Counter value.
    
29.   */
    
30. uint32_t RTC_GetWakeUpCounter(void)
    
31. {
    
32.   /* Get the counter value */
    
33.   return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT));
    
34. }
    

复制代码

10xjzheng

security 发表于 2015-9-30 10:36
以下免责，我没接触过STM32

RTC_GetWakeUpCounter这个还是获取的reloader的值啊

security

10xjzheng 发表于 2015-9-30 10:40
RTC_GetWakeUpCounter这个还是获取的reloader的值啊

那只能另想法子了，可以参考我上面的回复了
或者
- tickless使用sleep模式，这时，系统的的外在表现，还是running的，只是在背后悄悄地自动省电节能
- 当真正没有任何事件活跃的话，我们主动让系统进入深度睡眠，即STM32的STOP模式，此时也无需定时唤醒
系统就一直睡下去，等到异步唤醒事件发生，重新醒过来。

10xjzheng

security 发表于 2015-9-30 10:44
那只能另想法子了，可以参考我上面的回复了
或者
- tickless使用sleep模式，这时，系统的的外在表现，还 ...

我现在觉得还是改为sleep靠谱一点，置于“当真正没有任何事件活跃的话，我们主动让系统进入深度睡眠”，后面有应用是“真正没有任何事件活跃”再试试在stop和sleep之间切换。

10xjzheng

我又来了，这下子正常了，用的是sleep模式。我什么也不想说了，直接上图。

Excellence

10xjzheng 发表于 2015-9-30 10:25
霸气，论坛元老了！

多灌水，你也可以。O(∩_∩)O哈哈~。。。

tarchen

高手，佩服！谢谢分享！

yixin1851

学习学习，谢谢分享

10xjzheng

为了减少tickless“分包”进入休眠状态，因为定时器的计数值有限，定时的时间有限。这里把systick的时钟频率降低了。

rowa

看起来挺有意思哦

10xjzheng

后面我就在想，既然wakeup timer已经无法用了，那么我们是否可以试用下这样子的思路：
在run模式下，使用systick，然后在低功耗模式下使用RTC的闹钟来实现，RTC的闹钟是可以是秒以下级别的，可能RTC的闹钟也可以处理得比较长一些！RTC的闹钟同样是可以唤醒CPU的！

308594151

mark一下

TBG2

MARK，正在找这方面的内容。

edkaifa

一直想研究下低功耗

guo__qiu

因为之前我们假设了从哪里休眠就
从哪里唤醒，但是这次不是这样子的！这是需要注意的点，我现在想到的解决办法就是不在中断中让任务就绪。

在调用portSUPPRESS_TICKS_AND_SLEEP()之前已经将调度器挂起了，如下：所以PendSV中不进行任务的调度

1. 
   
2.         vTaskSuspendAll();
   
3.         {
   
4.                 /* Now the scheduler is suspended, the expected idle
   
5.                 time can be sampled again, and this time its value can
   
6.                 be used. */
   
7.                 configASSERT( xNextTaskUnblockTime >= xTickCount );
   
8.                 xExpectedIdleTime = prvGetExpectedIdleTime();
   
9. 
   
10.                 if( xExpectedIdleTime >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP )
    
11.                 {
    
12.                         traceLOW_POWER_IDLE_BEGIN();
    
13.                         portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime );
    
14.                         traceLOW_POWER_IDLE_END();
    
15.                 }
    
16.                 else
    
17.                 {
    
18.                         mtCOVERAGE_TEST_MARKER();
    
19.                 }
    
20.         }
    
21.         // 在这里才会进行调度
    
22.         ( void ) xTaskResumeAll();

复制代码

jiangkehong

进来学习一下低功耗