RT-Thread怎么休眠实现低功耗。

发布于 2017-09-01 11:23:13 浏览：6854 订阅该版

11 个回答

geniusgogo 认证专家 2017-09-01

这家伙很懒，什么也没写！

mmyer 2017-09-01

这家伙很懒，什么也没写！

mmyer 2017-09-04

这家伙很懒，什么也没写！

mmyer 2017-09-05

这家伙很懒，什么也没写！

mmyer 2017-09-06

这家伙很懒，什么也没写！

结合NRF和FREERTOS的例子，现在已经可以休眠了，但是休眠好像影响了TICK的长度，rt_thread_delay()的延时在使能休眠的情况下明显长很多，不知何故，具体的原因还要查查。以下是我的代码，系统时钟和休眠时钟用的都是RTC：

```
static void _wakeup_tick_adjust(uint32_t diff)
{
    uint32_t level;

level = rt_hw_interrupt_disable();

rt_tick_set(rt_tick_get() + diff);

if (rt_thread_self() != RT_NULL)
    {
    	struct rt_thread *thread;

/* check time slice */
        thread = rt_thread_self();

if (thread->remaining_tick <= diff)
        {
            /* change to initialized tick */
            thread->remaining_tick = thread->init_tick;

/* yield */
            rt_thread_yield();
        }
        else
        {
            thread->remaining_tick -= diff;
        }

/* check timer */
        rt_timer_check();
    }

rt_hw_interrupt_enable(level);
}

static void _sleep_ongo( uint32_t idle_tick )
{
  unsigned long cnt_before_sleep, cnt_afer_sleep;
  unsigned long rtc_load_value, gone_tick;
  bool rtcFlag;
//  CORE_DECLARE_IRQ_STATE;

/* Make sure the SysTick reload value does not overflow the counter. */
    if ( idle_tick >  TIMER_CAPACITY / CNT_PER_ONT_TICK )
    {
        idle_tick = TIMER_CAPACITY / CNT_PER_ONT_TICK;
    }

/* Calculate the reload value required to wait idle_tick
   * tick periods. */
  rtc_load_value = (CNT_PER_ONT_TICK * idle_tick)&0xfffffe;
  if (rtc_load_value > timer_compensation) {
    /* Compensate for the fact that the RTC is going to be stopped
     * momentarily. */
    rtc_load_value -= timer_compensation;
  }

/* Stop the RTC momentarily.  The time the RTC is stopped for is accounted
   * for as best it can be, but using the tickless mode will inevitably result
   * in some tiny drift of the time maintained by the kernel with respect to
   * calendar time.  The count is latched before stopping the timer as stopping
   * the timer appears to clear the count. */
  cnt_before_sleep = RTC_CounterGet();
  RTC_Enable(false);

/* If this function is re-entered before one complete tick period then the
   * reload value might be set to take into account a partial time slice. So
   * we adjust the count before sleep to take this into account.
   *
   * Just reading the count would be wrong, as it assumes that we are
   * counting up to a full ticks worth.
   */
  cnt_before_sleep += (CNT_PER_ONT_TICK - RTC_CompareGet(0));

/* Enter a critical section but don't use the taskENTER_CRITICAL()
   * method as that will mask interrupts that should exit sleep mode. */
  //CORE_ENTER_CRITICAL();
    rt_enter_critical();
#if 0
  /* If a context switch is pending or a task is waiting for the scheduler
   * to be unsuspended then abandon the low power entry. */
  if (eTaskConfirmSleepModeStatus() == eAbortSleep) {
    /* Restart tick and count up to whatever was left of the current time
     * slice. */
    RTC_CompareSet(0, (CNT_PER_ONT_TICK - cnt_before_sleep));
    RTC_Enable(true);

/* Re-enable interrupts */
    CORE_EXIT_CRITICAL();
  } else 
#endif
  {
    /* Adjust the reload value to take into account that the current time
     * slice is already partially complete. */
    rtc_load_value -= cnt_before_sleep;
    RTC_CompareSet(0, rtc_load_value);
    RTC_IntClear(_RTC_IFC_MASK);

//RTC_IntEnable(RTC_IF_COMP0);
    /* Restart the counter */
    RTC_Enable(true);

/* Sleep until something happens. save cpu status before sleep,restore when wakeup*/
    EMU_EnterEM2(RT_TRUE);

/* Stop the RTC and save the counter value since stopping the RTC clears
     * the counter. Again, the time the SysTick is stopped for is
     * accounted for as best it can be, but using the tickless mode will
     * inevitably result in some tiny drift of the time maintained by the
     * kernel with respect to calendar time. */
    cnt_afer_sleep = RTC_CounterGet();
    RTC_Enable(false);
    rtcFlag = (RTC_IntGet() & RTC_IF_COMP0) != 0;

/* Re-enable interrupts */
    //CORE_EXIT_CRITICAL();

if (rtcFlag) {
      /* The tick interrupt handler will already have pended the tick
       * processing in the kernel.  As the pending tick will be
       * processed as soon as this function exits, the tick value
       * maintained by the tick is stepped forward by one less than the
       * time spent waiting. */
      gone_tick = idle_tick - 1UL;
    } else {
      /* Some other interrupt than the RTC ended the sleep, now we need to
       * calculate how much time has passed since the last tick. */
      cnt_afer_sleep += cnt_before_sleep;

/* Calculate how many complete ticks have passed since the last tick */
      gone_tick = cnt_afer_sleep / CNT_PER_ONT_TICK;

/* The reload value is set to whatever fraction of a single tick
       * period remains. */
      cnt_afer_sleep -= (gone_tick * CNT_PER_ONT_TICK);
      rtc_load_value = CNT_PER_ONT_TICK - cnt_afer_sleep;

RTC_IntClear(_RTC_IFC_MASK);
      
      /* Reset the RTC compare value to trigger at the configured tick rate */
      RTC_CompareSet(0, rtc_load_value);
    }

/* Start the counter */
    RTC_Enable(true);

/* The tick forward by the number of tick periods that
     * remained in a low power state. */
    _wakeup_tick_adjust(gone_tick);
    
    rt_exit_critical();
  }
}

void rt_hw_system_powersave(void)
{
  uint32_t idle_tick;
  
  idle_tick = rt_timer_next_timeout_tick() - rt_tick_get();
  
  if ( idle_tick >= EXPECTED_IDLE_TIME_BEFORE_SLEEP)
  {
    // rt_kprintf("sleep entry:%u
", rt_tick_get());
    _sleep_ongo( idle_tick );
  }
}
```