外行问嵌入式OS低功耗问题

btcamel

单片机有低功耗模式，比如HALT，或者STANDBY模式
如果移植了FREE RTOS，那么是不是这些模式就不能进入了呢？
或者说，低功耗模式如何与OS良好协作呢？ 谢谢

electrlife

使用RTOS了也可以进入低功耗模式，但是必须有一个定时器可以唤醒MCU。
你可以在IDLE任务中使用MCU进入STANDY模式，但是需要处理一个时钟节拍，
如你进入睡眠的时间就是RTOS中延时列表中时间最长的那个，另外如果睡眠过程
中有其它的事件唤醒MCU，此时你还需要处理RTOS时钟节拍！

xiaoxu191

2楼厉害，学习了。个人觉得处理起来还是有些难度的。

sunnyqd

2楼正解

aozima

2楼正解。

lyzhangxiang

看下freertos 官方有相关文献

低功耗方面 有说怎么做的

Eric2013

FreeRTOS就支持低功耗模式，不能说是完美支持，还是非常不错的，RTOS中的低功耗常用的方法叫tickless模式。

去年号称超低功耗的EMF32, 公司是Energy Micro ，专门给RTX做的超低功耗绝对不是盖的，有机会可以研究研究，
不过源码没找到。

Eric2013

FreeRTOS的tickless模式在文件port.C里面，内容如下，看下大概的注释就懂是什么意思了。

1. #if configUSE_TICKLESS_IDLE == 1
   
2. 
   
3.         __weak void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
   
4.         {
   
5.         uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickCTRL;
   
6.         TickType_t xModifiableIdleTime;
   
7. 
   
8.                 /* Make sure the SysTick reload value does not overflow the counter. */
   
9.                 if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
   
10.                 {
    
11.                         xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
    
12.                 }
    
13. 
    
14.                 /* Stop the SysTick momentarily.  The time the SysTick is stopped for
    
15.                 is accounted for as best it can be, but using the tickless mode will
    
16.                 inevitably result in some tiny drift of the time maintained by the
    
17.                 kernel with respect to calendar time. */
    
18.                 portNVIC_SYSTICK_CTRL_REG &= ~portNVIC_SYSTICK_ENABLE_BIT;
    
19. 
    
20.                 /* Calculate the reload value required to wait xExpectedIdleTime
    
21.                 tick periods.  -1 is used because this code will execute part way
    
22.                 through one of the tick periods. */
    
23.                 ulReloadValue = portNVIC_SYSTICK_CURRENT_VALUE_REG + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
    
24.                 if( ulReloadValue > ulStoppedTimerCompensation )
    
25.                 {
    
26.                         ulReloadValue -= ulStoppedTimerCompensation;
    
27.                 }
    
28. 
    
29.                 /* Enter a critical section but don't use the taskENTER_CRITICAL()
    
30.                 method as that will mask interrupts that should exit sleep mode. */
    
31.                 __disable_irq();
    
32. 
    
33.                 /* If a context switch is pending or a task is waiting for the scheduler
    
34.                 to be unsuspended then abandon the low power entry. */
    
35.                 if( eTaskConfirmSleepModeStatus() == eAbortSleep )
    
36.                 {
    
37.                         /* Restart from whatever is left in the count register to complete
    
38.                         this tick period. */
    
39.                         portNVIC_SYSTICK_LOAD_REG = portNVIC_SYSTICK_CURRENT_VALUE_REG;
    
40. 
    
41.                         /* Restart SysTick. */
    
42.                         portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
    
43. 
    
44.                         /* Reset the reload register to the value required for normal tick
    
45.                         periods. */
    
46.                         portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
    
47. 
    
48.                         /* Re-enable interrupts - see comments above __disable_irq() call
    
49.                         above. */
    
50.                         __enable_irq();
    
51.                 }
    
52.                 else
    
53.                 {
    
54.                         /* Set the new reload value. */
    
55.                         portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
    
56. 
    
57.                         /* Clear the SysTick count flag and set the count value back to
    
58.                         zero. */
    
59.                         portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
    
60. 
    
61.                         /* Restart SysTick. */
    
62.                         portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
    
63. 
    
64.                         /* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
    
65.                         set its parameter to 0 to indicate that its implementation contains
    
66.                         its own wait for interrupt or wait for event instruction, and so wfi
    
67.                         should not be executed again.  However, the original expected idle
    
68.                         time variable must remain unmodified, so a copy is taken. */
    
69.                         xModifiableIdleTime = xExpectedIdleTime;
    
70.                         configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
    
71.                         if( xModifiableIdleTime > 0 )
    
72.                         {
    
73.                                 __dsb( portSY_FULL_READ_WRITE );
    
74.                                 __wfi();
    
75.                                 __isb( portSY_FULL_READ_WRITE );
    
76.                         }
    
77.                         configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
    
78. 
    
79.                         /* Stop SysTick.  Again, the time the SysTick is stopped for is
    
80.                         accounted for as best it can be, but using the tickless mode will
    
81.                         inevitably result in some tiny drift of the time maintained by the
    
82.                         kernel with respect to calendar time. */
    
83.                         ulSysTickCTRL = portNVIC_SYSTICK_CTRL_REG;
    
84.                         portNVIC_SYSTICK_CTRL_REG = ( ulSysTickCTRL & ~portNVIC_SYSTICK_ENABLE_BIT );
    
85. 
    
86.                         /* Re-enable interrupts - see comments above __disable_irq() call
    
87.                         above. */
    
88.                         __enable_irq();
    
89. 
    
90.                         if( ( ulSysTickCTRL & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
    
91.                         {
    
92.                                 uint32_t ulCalculatedLoadValue;
    
93. 
    
94.                                 /* The tick interrupt has already executed, and the SysTick
    
95.                                 count reloaded with ulReloadValue.  Reset the
    
96.                                 portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick
    
97.                                 period. */
    
98.                                 ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
    
99. 
    
100.                                 /* Don't allow a tiny value, or values that have somehow
     
101.                                 underflowed because the post sleep hook did something
     
102.                                 that took too long. */
     
103.                                 if( ( ulCalculatedLoadValue < ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
     
104.                                 {
     
105.                                         ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
     
106.                                 }
     
107. 
     
108.                                 portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
     
109. 
     
110.                                 /* The tick interrupt handler will already have pended the tick
     
111.                                 processing in the kernel.  As the pending tick will be
     
112.                                 processed as soon as this function exits, the tick value
     
113.                                 maintained by the tick is stepped forward by one less than the
     
114.                                 time spent waiting. */
     
115.                                 ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
     
116.                         }
     
117.                         else
     
118.                         {
     
119.                                 /* Something other than the tick interrupt ended the sleep.
     
120.                                 Work out how long the sleep lasted rounded to complete tick
     
121.                                 periods (not the ulReload value which accounted for part
     
122.                                 ticks). */
     
123.                                 ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - portNVIC_SYSTICK_CURRENT_VALUE_REG;
     
124. 
     
125.                                 /* How many complete tick periods passed while the processor
     
126.                                 was waiting? */
     
127.                                 ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
     
128. 
     
129.                                 /* The reload value is set to whatever fraction of a single tick
     
130.                                 period remains. */
     
131.                                 portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1 ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
     
132.                         }
     
133. 
     
134.                         /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG
     
135.                         again, then set portNVIC_SYSTICK_LOAD_REG back to its standard
     
136.                         value.  The critical section is used to ensure the tick interrupt
     
137.                         can only execute once in the case that the reload register is near
     
138.                         zero. */
     
139.                         portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
     
140.                         portENTER_CRITICAL();
     
141.                         {
     
142.                                 portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
     
143.                                 vTaskStepTick( ulCompleteTickPeriods );
     
144.                                 portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
     
145.                         }
     
146.                         portEXIT_CRITICAL();
     
147.                 }
     
148.         }
     
149. 
     
150. #endif /* #if configUSE_TICKLESS_IDLE */

复制代码

btcamel

非常感谢楼上各位的回复， 既然肯定是能实现，那我就不担心了。 谢谢各位！