STM32L4 运行FreeRTOS之STOP2低功耗模式

/**
  ******************************************************************************
  * @file    FreeRTOS\FreeRTOS_LowPower_LPTIM\Src\low_power_tick_management_LPTIM.c
  * @author  MCD Application Team
  * @brief   RTOS Low power tick management using LPTIM peripheral.    
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************  
  */


#include "cmsis_os2.h"
#include "FreeRTOS.h"
#include "task.h"
#include "stm32l4xx_hal.h"
#include "stm32l4xx_timebase_lptim.h"

#define portMAX_16_BIT_NUMBER	       ( 0xffffUL )

extern LPTIM_HandleTypeDef             LptimHandle;

extern void EntryStopMode( void );
extern void ExitStopMode( void );

void vPortSetupTimerInterrupt( void );

#if( configUSE_TICKLESS_IDLE == 2 )

/*
 * Override the default definition of vPortSuppressTicksAndSleep() that is
 * weakly defined in the FreeRTOS Cortex-M port layer with a version that
 * manages the LPTIM clock, as the tick is generated from the low power LPTIM
 * and not the SysTick as would normally be the case on a Cortex-M.
 */
void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime );


/*-----------------------------------------------------------*/

/* Calculate how many clock increments make up a single tick period. */
//static const uint32_t ulReloadValueForOneTick = (LSI_VALUE / configTICK_RATE_HZ);

//static const uint32_t ulReloadValueForOneSec = LSI_VALUE;

static const uint32_t ulReloadValueForOneTick = (LSI_VALUE /2 / configTICK_RATE_HZ);

static const uint32_t ulReloadValueForOneSec = LSI_VALUE/2;

/* Will hold the maximum number of ticks that can be suppressed. */
static uint32_t xMaximumPossibleSuppressedTicks = 0;

/* Flag set from the tick interrupt to allow the stop processing to know if
stop mode was exited because of a timer interrupt or a different interrupt. */
volatile BaseType_t ulTickFlag = pdFALSE;

#endif


/*-----------------------------------------------------------*/

void vPortSetupTimerInterrupt( void )
{
  InitTick(configLIBRARY_LOWEST_INTERRUPT_PRIORITY);
	
#if( configUSE_TICKLESS_IDLE == 2 )

	/* The maximum number of ticks that can be suppressed depends on the clock
	frequency. */
	xMaximumPossibleSuppressedTicks = (portMAX_16_BIT_NUMBER * configTICK_RATE_HZ) / ulReloadValueForOneSec;
#endif	/* ( configUSE_TICKLESS_IDLE == 2 ) */
}



#if( configUSE_TICKLESS_IDLE == 2 )
/*-----------------------------------------------------------*/

void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
{
  uint32_t ulReloadValue, ulCompleteTickPeriods, ulCount;
  eSleepModeStatus eSleepAction;
	TickType_t xModifiableIdleTime;

	/* THIS FUNCTION IS CALLED WITH THE SCHEDULER SUSPENDED. */

	/* Make sure the LPTIM reload value does not overflow the counter. */
	if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
	{
		xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
	}

	/* Calculate the reload value required to wait xExpectedIdleTime tick periods. */
  ulReloadValue = (ulReloadValueForOneSec * (xExpectedIdleTime - 1UL))/configTICK_RATE_HZ;
	
	ulCount = HAL_LPTIM_ReadCounter(&LptimHandle);
	
	HAL_LPTIM_PWM_Stop_IT(&LptimHandle);

	/* Enter a critical section but don't use the taskENTER_CRITICAL() method as
	that will mask interrupts that should exit sleep mode. */
	__asm volatile ( "cpsid i" );
	__asm volatile( "dsb" );
	__asm volatile( "isb" );

	/* The tick flag is set to false before sleeping.  If it is true when sleep
	mode is exited then sleep mode was probably exited because the tick was
	suppressed for the entire xExpectedIdleTime period. */
	ulTickFlag = pdFALSE;

	/* If a context switch is pending then abandon the low power entry as the
	context switch might have been pended by an external interrupt that	requires
	processing. */
	eSleepAction = eTaskConfirmSleepModeStatus();
	if( eSleepAction == eAbortSleep )
	{
		/* Restart tick and continue counting to complete the current time
		slice. */
                __HAL_LPTIM_ENABLE_IT(&LptimHandle, LPTIM_IT_ARRM);
                __HAL_LPTIM_ENABLE(&LptimHandle);
                __HAL_LPTIM_AUTORELOAD_SET(&LptimHandle, ulCount);
                __HAL_LPTIM_COMPARE_SET(&LptimHandle, (ulCount/2));
                __HAL_LPTIM_START_CONTINUOUS(&LptimHandle);
         
		/* Re-enable interrupts  */
		__asm volatile ( "cpsie i" );
	}
	else
	{		
		
    /* Strat LPTIM Timeout wake up based on expected idle time */
    HAL_LPTIM_TimeOut_Start_IT(&LptimHandle, 0xFFFF, ulReloadValue);
		
		/* A user definable macro that allows application code to be inserted
		here.  Such application code can be used to minimise power consumption
		further by turning off IO, peripheral clocks, the Flash, etc. */
//		configPRE_STOP_PROCESSING();
		xModifiableIdleTime = xExpectedIdleTime;
//		PreSleepProcessing( &xModifiableIdleTime );
		EntryStopMode();

		/* There are no running state tasks and no tasks that are blocked with a
		time out.  Assuming the application does not care if the tick time slips
		with respect to calendar time then enter a deep sleep that can only be
		woken by (in this demo case) the user button being pushed on the
		STM32L discovery board.  If the application does require the tick time
		to keep better track of the calender time then the LPTIM peripheral can be
		used to make rough adjustments. */
                
    /* Enter STOP 1 mode */
//    HAL_PWREx_EnterSTOP1Mode(PWR_STOPENTRY_WFI);
		/* Enter STOP 1 mode */
		HAL_PWREx_EnterSTOP2Mode(PWR_STOPENTRY_WFI);
                
		/* A user definable macro that allows application code to be inserted
		here.  Such application code can be used to reverse any actions taken
		by the configPRE_STOP_PROCESSING().  In this demo
		configPOST_STOP_PROCESSING() is used to re-initialise the clocks that
		were turned off when STOP mode was entered. */
//		configPOST_STOP_PROCESSING();
//		PostSleepProcessing( &xExpectedIdleTime );
		ExitStopMode();
		
		ulCount = HAL_LPTIM_ReadCounter(&LptimHandle);

                HAL_LPTIM_TimeOut_Stop_IT(&LptimHandle);

		/* Re-enable interrupts */
                __asm volatile ( "cpsie i" );
		
                if( ulTickFlag != pdFALSE )
		{
			ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
                        
                        __HAL_LPTIM_ENABLE_IT(&LptimHandle, LPTIM_IT_ARRM);
                        __HAL_LPTIM_ENABLE(&LptimHandle);
                        __HAL_LPTIM_AUTORELOAD_SET(&LptimHandle, ulReloadValueForOneTick);
                        __HAL_LPTIM_COMPARE_SET(&LptimHandle, (ulReloadValueForOneTick/2));
                        __HAL_LPTIM_START_CONTINUOUS(&LptimHandle);
                        
		}
		else
		{
			ulCompleteTickPeriods = (ulCount * configTICK_RATE_HZ)/ ulReloadValueForOneSec;
			ulReloadValue = (ulReloadValueForOneTick - ( ulCompleteTickPeriods % ulReloadValueForOneTick ));
                        
                        __HAL_LPTIM_ENABLE_IT(&LptimHandle, LPTIM_IT_ARRM);
                        __HAL_LPTIM_ENABLE(&LptimHandle);
                        __HAL_LPTIM_AUTORELOAD_SET(&LptimHandle, ulReloadValue);
                        __HAL_LPTIM_COMPARE_SET(&LptimHandle, (ulReloadValue/2));
                        __HAL_LPTIM_START_CONTINUOUS(&LptimHandle);                  
                        
		}
		
                /* update HAL base time */
                uwTick += ulCompleteTickPeriods;
                
		/* Wind the tick forward by the number of tick periods that the CPU
		remained in a low power state. */
		vTaskStepTick( ulCompleteTickPeriods );
	}
}
#endif /* ( configUSE_TICKLESS_IDLE == 2 ) */
	

/**
  ******************************************************************************
  * @file    stm32l47xx_os_timebase_lptim.c 
  * @author  MCD Application Team
  * @brief   RTOS and HAL time base based on LPTIM.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "stm32l4xx_hal.h"
#include "FreeRTOS.h"
#include "task.h"
#include "stm32l4xx_timebase_lptim.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/

/* Set the Maximum value of the counter (Auto-Reload) that defines the Period */
//#define PeriodValue             (uint32_t) (32)
#define PeriodValue             (uint32_t) (16)

/* Set the Compare value that defines the duty cycle */
//#define PulseValue              (uint32_t) (16)
#define PulseValue              (uint32_t) (8)

/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* LPTIM handle declaration */
LPTIM_HandleTypeDef             LptimHandle;

__IO uint32_t ulTickInit = 0;

/* Clocks structure declaration */
RCC_PeriphCLKInitTypeDef        RCC_PeriphCLKInitStruct;

#if( configUSE_TICKLESS_IDLE == 2 )
extern uint32_t ulTickFlag;
#endif

/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/**
  * @brief  This function configures the LPTIM to generate an interrupt each 1ms. 
  * @param  TickPriority: Tick interrupt priority.
  * @retval HAL status
*/
void InitTick (uint32_t TickPriority)
{
  RCC_OscInitTypeDef RCC_OscInitStruct;
  
  if(ulTickInit == 0)
  {
    /* Enable LSE clock */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
    RCC_OscInitStruct.LSIState = RCC_LSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
    HAL_RCC_OscConfig(&RCC_OscInitStruct);
    
    /* ### - 1 - Re-target the LSE to Clock the LPTIM Counter ################# */
    /* Select the LSE clock as LPTIM peripheral clock */
    RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_LPTIM1;
    RCC_PeriphCLKInitStruct.Lptim1ClockSelection = RCC_LPTIM1CLKSOURCE_LSI;  
    HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);
    
    /* ### - 2 - Initialize LPTIM peripheral ################################## */
    /*
    *  Instance        = LPTIM1
    *  Clock Source    = APB or LowPowerOSCillator (in this example LSE is
    *                    already selected from the RCC stage)
    *  Clock prescaler = 1 (No division)
    *  Counter source  = Internal event.   
    *  Counter Trigger = Software trigger
    *  Output Polarity = High
    *  Update mode     = Immediate (Registers are immediately updated after any
    *                    write access) 
    */
    
    LptimHandle.Instance = LPTIM1;
    
    LptimHandle.Init.Clock.Source    = LPTIM_CLOCKSOURCE_APBCLOCK_LPOSC;
//    LptimHandle.Init.Clock.Prescaler = LPTIM_PRESCALER_DIV1;
		LptimHandle.Init.Clock.Prescaler = LPTIM_PRESCALER_DIV2;
    LptimHandle.Init.CounterSource   = LPTIM_COUNTERSOURCE_INTERNAL;  
    LptimHandle.Init.Trigger.Source  = LPTIM_TRIGSOURCE_SOFTWARE; 
    LptimHandle.Init.OutputPolarity  = LPTIM_OUTPUTPOLARITY_HIGH;
    LptimHandle.Init.UpdateMode      = LPTIM_UPDATE_IMMEDIATE;
    LptimHandle.Init.Input1Source    = LPTIM_INPUT1SOURCE_GPIO;
    LptimHandle.Init.Input2Source    = LPTIM_INPUT2SOURCE_GPIO;
    
    /* Initialize LPTIM peripheral according to the passed parameters */
    if (HAL_LPTIM_Init(&LptimHandle) != HAL_OK)
    {
      while(1);
    }	
    
    /* Enable LPTIM NVIC Interrupt */
    HAL_NVIC_SetPriority(LPTIM1_IRQn, TickPriority, 0U);
    HAL_NVIC_EnableIRQ(LPTIM1_IRQn);
    
    /* ### - 3 - Start generating the PWM signal ############################## */
    /*
    *  Period = 31
    *  Pulse  = 15
    *  According to this configuration, the duty cycle will be equal to 50%
    */
    __HAL_LPTIM_ENABLE_IT(&LptimHandle, LPTIM_IT_ARRM);
    __HAL_LPTIM_ENABLE(&LptimHandle);
    __HAL_LPTIM_AUTORELOAD_SET(&LptimHandle, PeriodValue);
    __HAL_LPTIM_COMPARE_SET(&LptimHandle, PulseValue);
    __HAL_LPTIM_START_CONTINUOUS(&LptimHandle);  
    
    ulTickInit = 1;
  }
}

/**
  * @brief This function configures the source of the time base. 
  *        The time source is configured  to have 1ms time base with a dedicated 
  *        Tick interrupt priority. 
  * @param TickPriority: Tick interrupt priority.
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority)
{
  InitTick(TickPriority);
	
  return HAL_OK;
}


void HAL_LPTIM_CompareMatchCallback(LPTIM_HandleTypeDef *hlptim)
{  
#if( configUSE_TICKLESS_IDLE == 2 )
  ulTickFlag = pdTRUE;
#endif
}

/*************************** Additional specific APIs to Free RTOS ************/
/**
* @brief  Handles the tick increment
* @param  none.
* @retval none.
*/
void osSystickHandler(void)
{

#if (INCLUDE_xTaskGetSchedulerState  == 1 )
  if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED)
  {
#endif  /* INCLUDE_xTaskGetSchedulerState */  
    xPortSysTickHandler();
#if (INCLUDE_xTaskGetSchedulerState  == 1 )
  }
#endif  /* INCLUDE_xTaskGetSchedulerState */  
}

/**
  * @brief  Autoreload match callback in non blocking mode 
  * @param  hlptim : LPTIM handle
  * @retval None
  */
void HAL_LPTIM_AutoReloadMatchCallback(LPTIM_HandleTypeDef *hlptim)
{
  if (HAL_LPTIM_ReadAutoReload(hlptim) != PeriodValue)
  {
    __HAL_LPTIM_ENABLE_IT(hlptim, LPTIM_IT_ARRM);
    __HAL_LPTIM_ENABLE(hlptim);
    __HAL_LPTIM_AUTORELOAD_SET(hlptim, PeriodValue);
    __HAL_LPTIM_COMPARE_SET(hlptim, (PulseValue));
    __HAL_LPTIM_START_CONTINUOUS(hlptim);  
  } 
  
  HAL_IncTick();
  osSystickHandler();
}

/**
  * @brief  This function handles  WAKE UP TIMER  interrupt request.
  * @param  None
  * @retval None
  */
void LPTIM1_IRQHandler(void)
{
  /* Compare match interrupt */
  if(__HAL_LPTIM_GET_FLAG(&LptimHandle, LPTIM_FLAG_CMPM) != RESET)
  {
      /* Clear Compare match flag */
      __HAL_LPTIM_CLEAR_FLAG(&LptimHandle, LPTIM_FLAG_CMPM);
      
      /* Compare match Callback */
      HAL_LPTIM_CompareMatchCallback(&LptimHandle);  
  }
  
  if(__HAL_LPTIM_GET_FLAG(&LptimHandle, LPTIM_FLAG_ARRM) != RESET)
  {
      /* Clear ARRM flag */
      __HAL_LPTIM_CLEAR_FLAG(&LptimHandle, LPTIM_FLAG_ARRM);
      
      /* ARRM Callback */
      HAL_LPTIM_AutoReloadMatchCallback(&LptimHandle);  
  }
  
}

/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

/**
  ******************************************************************************
  * @file    stm32l4xx_os_timebase_lptim.h 
  * @author  MCD Application Team
  * @brief   RTOS and HAL time base based on LPTIM header file.
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2017 STMicroelectronics International N.V. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without 
  * modification, are permitted, provided that the following conditions are met:
  *
  * 1. Redistribution of source code must retain the above copyright notice, 
  *    this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright notice,
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  * 3. Neither the name of STMicroelectronics nor the names of other 
  *    contributors to this software may be used to endorse or promote products 
  *    derived from this software without specific written permission.
  * 4. This software, including modifications and/or derivative works of this 
  *    software, must execute solely and exclusively on microcontroller or
  *    microprocessor devices manufactured by or for STMicroelectronics.
  * 5. Redistribution and use of this software other than as permitted under 
  *    this license is void and will automatically terminate your rights under 
  *    this license. 
  *
  * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" 
  * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT 
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
  * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
  * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT 
  * SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */

#ifndef __RTOS_LPTIM_BASE_TIME_H
#define __RTOS_LPTIM_BASE_TIME_H

#ifdef __cplusplus
 extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "stm32l4xx_hal.h"
/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/
void InitTick (uint32_t TickPriority);
void LPTIM1_IRQHandler(void);
  
#ifdef __cplusplus
}
#endif

#endif /* */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/