956 lines
40 KiB
C
956 lines
40 KiB
C
/**
|
||
******************************************************************************
|
||
* @file plib035_rcu.h
|
||
*
|
||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||
* RCU (Reset & Clock control Unit), а также сопутствующие
|
||
* макроопределения и перечисления
|
||
*
|
||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||
*
|
||
******************************************************************************
|
||
* @attention
|
||
*
|
||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||
*
|
||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||
******************************************************************************
|
||
*/
|
||
|
||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||
#ifndef __PLIB035_RCU_H
|
||
#define __PLIB035_RCU_H
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
/* Includes ------------------------------------------------------------------*/
|
||
#include "plib035.h"
|
||
|
||
/** @addtogroup Peripheral
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup RCU
|
||
* @brief Драйвер для работы с тактированием и сбросом периферийных блоков
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup RCU_Exported_Defines Константы
|
||
* @{
|
||
*/
|
||
|
||
/** @defgroup RCU_ClkStatus_Define Cтатусы источников тактового сигнала
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_ClkStatus_SysClkFail RCU_SYSCLKSTAT_SYSFAIL_Msk /*!< Ошибка текущей системной частоты */
|
||
#define RCU_ClkStatus_OSEClkFail RCU_SYSCLKSTAT_OSECLKERR_Msk /*!< Ошибка сигнала внешнего осциллятора */
|
||
#define RCU_ClkStatus_PLLClkFail RCU_SYSCLKSTAT_PLLCLKERR_Msk /*!< Ошибка сигнала с PLL */
|
||
#define RCU_ClkStatus_PLLDivClkFail RCU_SYSCLKSTAT_PLLDIVCLKERR_Msk /*!< Ошибка сигнала с деленного выхода PLL */
|
||
#define RCU_ClkStatus_OSEClkGood RCU_SYSCLKSTAT_OSECLKOK_Msk /*!< Нормальная работа сигнала внешнего осциллятора */
|
||
#define RCU_ClkStatus_PLLClkGood RCU_SYSCLKSTAT_PLLCLKOK_Msk /*!< Нормальная работа сигнала с PLL */
|
||
#define RCU_ClkStatus_PLLDivClkGood RCU_SYSCLKSTAT_PLLDIVCLKOK_Msk /*!< Нормальная работа сигнала с деленного выхода PLL */
|
||
|
||
#define IS_RCU_CLK_STATUS(VALUE) (((VALUE) == RCU_ClkStatus_SysClkFail) || \
|
||
((VALUE) == RCU_ClkStatus_OSEClkFail) || \
|
||
((VALUE) == RCU_ClkStatus_PLLClkFail) || \
|
||
((VALUE) == RCU_ClkStatus_PLLDivClkFail) || \
|
||
((VALUE) == RCU_ClkStatus_OSEClkGood) || \
|
||
((VALUE) == RCU_ClkStatus_PLLClkGood) || \
|
||
((VALUE) == RCU_ClkStatus_PLLDivClkGood))
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_RstStatus_Define Источник, вызвавший последний сброс системы
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_RstStatus_POR RCU_SYSRSTSTAT_POR_Msk /*!< Сброс от блока POR */
|
||
#define RCU_RstStatus_WDT RCU_SYSRSTSTAT_WDOG_Msk /*!< Сброс от сторожевого таймера */
|
||
#define RCU_RstStatus_Sys RCU_SYSRSTSTAT_SYSRST_Msk /*!< Системный сброс */
|
||
#define RCU_RstStatus_LockUp RCU_SYSRSTSTAT_LOCKUP_Msk /*!< Сброс по состоянию LockUp ядра */
|
||
|
||
#define IS_RCU_RST_STATUS(VALUE) (((VALUE) == RCU_RstStatus_POR) || \
|
||
((VALUE) == RCU_RstStatus_WDT) || \
|
||
((VALUE) == RCU_RstStatus_Sys) || \
|
||
((VALUE) == RCU_RstStatus_LockUp))
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_ITSource_Define Источники прерываний
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_ITSource_OSEClkFail RCU_INTEN_OSECLKERR_Msk /*!< Произошла ошибка сигнала внешнего осциллятора */
|
||
#define RCU_ITSource_PLLClkFail RCU_INTEN_PLLCLKERR_Msk /*!< Произошла ошибка сигнала с PLL */
|
||
#define RCU_ITSource_PLLDivClkFail RCU_INTEN_PLLDIVCLKERR_Msk /*!< Произошла ошибка сигнала с деленного выхода PLL */
|
||
#define RCU_ITSource_OSEClkGood RCU_INTEN_OSECLKOK_Msk /*!< Произошел переход к нормальной работе сигнала внешнего осциллятора */
|
||
#define RCU_ITSource_PLLClkGood RCU_INTEN_PLLCLKOK_Msk /*!< Произошел переход к нормальной работе сигнала с PLL */
|
||
#define RCU_ITSource_PLLDivClkGood RCU_INTEN_PLLDIVCLKOK_Msk /*!< Произошел переход к нормальной работе сигнала с деленного выхода PLL */
|
||
#define RCU_ITSource_PLLLock RCU_INTEN_PLLLOCK_Msk /*!< Произошел захват частоты PLL */
|
||
|
||
#define IS_RCU_IT_SOURCE(VALUE) (((VALUE) == RCU_ITSource_OSEClkFail) || \
|
||
((VALUE) == RCU_ITSource_PLLClkFail) || \
|
||
((VALUE) == RCU_ITSource_PLLDivClkFail) || \
|
||
((VALUE) == RCU_ITSource_OSEClkGood) || \
|
||
((VALUE) == RCU_ITSource_PLLClkGood) || \
|
||
((VALUE) == RCU_ITSource_PLLDivClkGood) || \
|
||
((VALUE) == RCU_ITSource_PLLLock))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_ITStatus_Define Статусы прерываний
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_ITStatus_OSEClkFail RCU_INTSTAT_OSECLKERR_Msk /*!< Флаг ошибки сигнала внешнего осциллятора */
|
||
#define RCU_ITStatus_PLLClkFail RCU_INTSTAT_PLLCLKERR_Msk /*!< Флаг ошибки сигнала с PLL */
|
||
#define RCU_ITStatus_PLLDivClkFail RCU_INTSTAT_PLLDIVCLKERR_Msk /*!< Флаг ошибки сигнала с деленного выхода PLL */
|
||
#define RCU_ITStatus_OSEClkGood RCU_INTSTAT_OSECLKOK_Msk /*!< Флаг перехода к нормальной работе сигнала внешнего осциллятора */
|
||
#define RCU_ITStatus_PLLClkGood RCU_INTSTAT_PLLCLKOK_Msk /*!< Флаг перехода к нормальной работе сигнала с PLL */
|
||
#define RCU_ITStatus_PLLDivClkGood RCU_INTSTAT_PLLDIVCLKOK_Msk /*!< Флаг перехода к нормальной работе сигнала с деленного выхода PLL */
|
||
#define RCU_ITStatus_PLLLock RCU_INTSTAT_PLLLOCK_Msk /*!< Флаг захвата частоты PLL */
|
||
#define RCU_ITStatus_SysFail RCU_INTSTAT_SYSFAIL_Msk /*!< Флаг сбоя системной частоты */
|
||
|
||
#define IS_RCU_IT_STATUS(VALUE) (((VALUE) == RCU_ITStatus_OSEClkFail) || \
|
||
((VALUE) == RCU_ITStatus_PLLClkFail) || \
|
||
((VALUE) == RCU_ITStatus_PLLDivClkFail) || \
|
||
((VALUE) == RCU_ITStatus_OSEClkGood) || \
|
||
((VALUE) == RCU_ITStatus_PLLClkGood) || \
|
||
((VALUE) == RCU_ITStatus_PLLDivClkGood) || \
|
||
((VALUE) == RCU_ITStatus_PLLLock) || \
|
||
((VALUE) == RCU_ITStatus_SysFail))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_APBClk_Define Управление тактированием периферийных блоков APB
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_APBClk_TMR0 RCU_PCLKCFG_TMR0EN_Msk /*!< Управление тактированием блока TMR 0 */
|
||
#define RCU_APBClk_TMR1 RCU_PCLKCFG_TMR1EN_Msk /*!< Управление тактированием блока TMR 1 */
|
||
#define RCU_APBClk_TMR2 RCU_PCLKCFG_TMR2EN_Msk /*!< Управление тактированием блока TMR 2 */
|
||
#define RCU_APBClk_TMR3 RCU_PCLKCFG_TMR3EN_Msk /*!< Управление тактированием блока TMR 3 */
|
||
#define RCU_APBClk_PWM0 RCU_PCLKCFG_PWM0EN_Msk /*!< Управление тактированием блока PWM 0 */
|
||
#define RCU_APBClk_PWM1 RCU_PCLKCFG_PWM1EN_Msk /*!< Управление тактированием блока PWM 1 */
|
||
#define RCU_APBClk_PWM2 RCU_PCLKCFG_PWM2EN_Msk /*!< Управление тактированием блока PWM 2 */
|
||
#define RCU_APBClk_I2C RCU_PCLKCFG_I2CEN_Msk /*!< Управление тактированием блока I2C */
|
||
#define RCU_APBClk_QEP RCU_PCLKCFG_QEPEN_Msk /*!< Управление тактированием блока QEP */
|
||
#define RCU_APBClk_ECAP0 RCU_PCLKCFG_ECAP0EN_Msk /*!< Управление тактированием блока ECAP 0 */
|
||
#define RCU_APBClk_ECAP1 RCU_PCLKCFG_ECAP1EN_Msk /*!< Управление тактированием блока ECAP 1 */
|
||
#define RCU_APBClk_ECAP2 RCU_PCLKCFG_ECAP2EN_Msk /*!< Управление тактированием блока ECAP 2 */
|
||
|
||
#define IS_RCU_APB_CLK(VALUE) (((VALUE) == RCU_APBClk_TMR0) || \
|
||
((VALUE) == RCU_APBClk_TMR1) || \
|
||
((VALUE) == RCU_APBClk_TMR2) || \
|
||
((VALUE) == RCU_APBClk_TMR3) || \
|
||
((VALUE) == RCU_APBClk_PWM0) || \
|
||
((VALUE) == RCU_APBClk_PWM1) || \
|
||
((VALUE) == RCU_APBClk_PWM2) || \
|
||
((VALUE) == RCU_APBClk_I2C) || \
|
||
((VALUE) == RCU_APBClk_QEP) || \
|
||
((VALUE) == RCU_APBClk_ECAP0) || \
|
||
((VALUE) == RCU_APBClk_ECAP1) || \
|
||
((VALUE) == RCU_APBClk_ECAP2))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_AHBClk_Define Управление тактированием периферийных блоков AHB
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_AHBClk_GPIOA RCU_HCLKCFG_GPIOAEN_Msk /*!< Управление тактированием блока GPIOA */
|
||
#define RCU_AHBClk_GPIOB RCU_HCLKCFG_GPIOBEN_Msk /*!< Управление тактированием блока GPIOB */
|
||
#define RCU_AHBClk_CAN RCU_HCLKCFG_CANEN_Msk /*!< Управление тактированием блока CAN */
|
||
#define IS_RCU_AHB_CLK(VALUE) (((VALUE) == RCU_AHBClk_GPIOA) || \
|
||
((VALUE) == RCU_AHBClk_GPIOB) || \
|
||
((VALUE) == RCU_AHBClk_CAN))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_APBRst_Define Управление сбросом периферийных блоков APB
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_APBRst_TMR0 RCU_PRSTCFG_TMR0EN_Msk /*!< Управление сбросом блока TMR 0 */
|
||
#define RCU_APBRst_TMR1 RCU_PRSTCFG_TMR1EN_Msk /*!< Управление сбросом блока TMR 1 */
|
||
#define RCU_APBRst_TMR2 RCU_PRSTCFG_TMR2EN_Msk /*!< Управление сбросом блока TMR 2 */
|
||
#define RCU_APBRst_TMR3 RCU_PRSTCFG_TMR3EN_Msk /*!< Управление сбросом блока TMR 3 */
|
||
#define RCU_APBRst_PWM0 RCU_PRSTCFG_PWM0EN_Msk /*!< Управление сбросом блока PWM 0 */
|
||
#define RCU_APBRst_PWM1 RCU_PRSTCFG_PWM1EN_Msk /*!< Управление сбросом блока PWM 1 */
|
||
#define RCU_APBRst_PWM2 RCU_PRSTCFG_PWM2EN_Msk /*!< Управление сбросом блока PWM 2 */
|
||
#define RCU_APBRst_I2C RCU_PRSTCFG_I2CEN_Msk /*!< Управление сбросом блока I2C */
|
||
#define RCU_APBRst_QEP RCU_PRSTCFG_QEPEN_Msk /*!< Управление сбросом блока QEP */
|
||
#define RCU_APBRst_ECAP0 RCU_PRSTCFG_ECAP0EN_Msk /*!< Управление сбросом блока ECAP 0 */
|
||
#define RCU_APBRst_ECAP1 RCU_PRSTCFG_ECAP1EN_Msk /*!< Управление сбросом блока ECAP 1 */
|
||
#define RCU_APBRst_ECAP2 RCU_PRSTCFG_ECAP2EN_Msk /*!< Управление сбросом блока ECAP 2 */
|
||
|
||
#define IS_RCU_APB_RST(VALUE) (((VALUE) == RCU_APBRst_TMR0) || \
|
||
((VALUE) == RCU_APBRst_TMR1) || \
|
||
((VALUE) == RCU_APBRst_TMR2) || \
|
||
((VALUE) == RCU_APBRst_TMR3) || \
|
||
((VALUE) == RCU_APBRst_PWM0) || \
|
||
((VALUE) == RCU_APBRst_PWM1) || \
|
||
((VALUE) == RCU_APBRst_PWM2) || \
|
||
((VALUE) == RCU_APBRst_I2C) || \
|
||
((VALUE) == RCU_APBRst_QEP) || \
|
||
((VALUE) == RCU_APBRst_ECAP0) || \
|
||
((VALUE) == RCU_APBRst_ECAP1) || \
|
||
((VALUE) == RCU_APBRst_ECAP2))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_AHBRst_Define Управление сбросом периферийных блоков AHB
|
||
* @{
|
||
*/
|
||
|
||
#define RCU_AHBRst_GPIOA RCU_HRSTCFG_GPIOAEN_Msk /*!< Управление сбросом блока GPIOA */
|
||
#define RCU_AHBRst_GPIOB RCU_HRSTCFG_GPIOBEN_Msk /*!< Управление сбросом блока GPIOB */
|
||
#define RCU_AHBRst_CAN RCU_HRSTCFG_CANEN_Msk /*!< Управление сбросом блока CAN */
|
||
|
||
#define IS_RCU_AHB_RST(VALUE) (((VALUE) == RCU_AHBRst_GPIOA) || \
|
||
((VALUE) == RCU_AHBRst_GPIOB) || \
|
||
((VALUE) == RCU_AHBRst_CAN))
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_Exported_Types Типы
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Выбор источника опорного сигнала PLL.
|
||
*/
|
||
typedef enum {
|
||
RCU_PLL_Ref_OSEClk = RCU_PLLCFG_REFSRC_OSECLK, /*!< Сигнал внешнего осциллятора */
|
||
RCU_PLL_Ref_OSIClk = RCU_PLLCFG_REFSRC_OSICLK /*!< Сигнал внтуреннего осциллятора */
|
||
} RCU_PLL_Ref_TypeDef;
|
||
#define IS_RCU_PLL_REF(VALUE) (((VALUE) == RCU_PLL_Ref_OSEClk) || \
|
||
((VALUE) == RCU_PLL_Ref_OSIClk))
|
||
|
||
/**
|
||
* @brief Выходной делитель OD
|
||
*/
|
||
typedef enum {
|
||
RCU_PLL_OD_Disable = RCU_PLLCFG_OD_Disable, /*!< Делитель OD выключен */
|
||
RCU_PLL_OD_Div2 = RCU_PLLCFG_OD_Div2, /*!< Коэффициент деления OD равен 2 */
|
||
RCU_PLL_OD_Div4 = RCU_PLLCFG_OD_Div4, /*!< Коэффициент деления OD равен 4 */
|
||
RCU_PLL_OD_Div8 = RCU_PLLCFG_OD_Div8 /*!< Коэффициент деления OD равен 8 */
|
||
} RCU_PLL_OD_TypeDef;
|
||
#define IS_RCU_PLL_OD(VALUE) (((VALUE) == RCU_PLL_OD_Disable) || \
|
||
((VALUE) == RCU_PLL_OD_Div2) || \
|
||
((VALUE) == RCU_PLL_OD_Div4) || \
|
||
((VALUE) == RCU_PLL_OD_Div8))
|
||
|
||
/**
|
||
* @brief Выбор источника тактирования для периферийного блока c несколькими тактовыми доменами - ADC, UART, SPI
|
||
*/
|
||
typedef enum {
|
||
RCU_PeriphClk_OSEClk = RCU_SPICFG_CLKSEL_OSECLK, /*!< Сигнал внешнего осциллятора */
|
||
RCU_PeriphClk_PLLClk = RCU_SPICFG_CLKSEL_PLLCLK, /*!< Сигнал с PLL */
|
||
RCU_PeriphClk_PLLDivClk = RCU_SPICFG_CLKSEL_PLLDIVCLK, /*!< Сигнал с деленного выхода PLL */
|
||
RCU_PeriphClk_OSIClk = RCU_SPICFG_CLKSEL_OSICLK /*!< Сигнал внтуреннего осциллятора */
|
||
} RCU_PeriphClk_TypeDef;
|
||
#define IS_RCU_PERIPH_CLK(VALUE) (((VALUE) == RCU_PeriphClk_OSEClk) || \
|
||
((VALUE) == RCU_PeriphClk_PLLClk) || \
|
||
((VALUE) == RCU_PeriphClk_PLLDivClk) || \
|
||
((VALUE) == RCU_PeriphClk_OSIClk))
|
||
|
||
/**
|
||
* @brief Выбор источника тактирования для CLKOUT, TRACE, WDT.
|
||
*/
|
||
typedef enum {
|
||
RCU_SysPeriphClk_OSEClk = RCU_CLKOUTCFG_CLKSEL_OSECLK, /*!< Сигнал внешнего осциллятора */
|
||
RCU_SysPeriphClk_PLLClk = RCU_CLKOUTCFG_CLKSEL_PLLCLK, /*!< Сигнал с PLL */
|
||
RCU_SysPeriphClk_PLLDivClk = RCU_CLKOUTCFG_CLKSEL_PLLDIVCLK, /*!< Сигнал с деленного выхода PLL */
|
||
RCU_SysPeriphClk_OSIClk = RCU_CLKOUTCFG_CLKSEL_OSICLK /*!< Сигнал внтуреннего осциллятора */
|
||
} RCU_SysPeriphClk_TypeDef;
|
||
#define IS_RCU_SYS_PERIPH_CLK(VALUE) (((VALUE) == RCU_SysPeriphClk_OSEClk) || \
|
||
((VALUE) == RCU_SysPeriphClk_PLLClk) || \
|
||
((VALUE) == RCU_SysPeriphClk_PLLDivClk) || \
|
||
((VALUE) == RCU_SysPeriphClk_OSIClk))
|
||
|
||
/**
|
||
* @brief Выбор источника системной частоты.
|
||
*/
|
||
typedef enum {
|
||
RCU_SysClk_OSIClk = RCU_SYSCLKCFG_SYSSEL_OSICLK, /*!< Сигнал внтуреннего осциллятора */
|
||
RCU_SysClk_OSEClk = RCU_SYSCLKCFG_SYSSEL_OSECLK, /*!< Сигнал внешнего осциллятора */
|
||
RCU_SysClk_PLLClk = RCU_SYSCLKCFG_SYSSEL_PLLCLK, /*!< Сигнал с PLL */
|
||
RCU_SysClk_PLLDivClk = RCU_SYSCLKCFG_SYSSEL_PLLDIVCLK /*!< Сигнал с деленного выхода PLL */
|
||
} RCU_SysClk_TypeDef;
|
||
#define IS_RCU_SYS_CLK(VALUE) (((VALUE) == RCU_SysClk_OSIClk) || \
|
||
((VALUE) == RCU_SysClk_OSEClk) || \
|
||
((VALUE) == RCU_SysClk_PLLClk) || \
|
||
((VALUE) == RCU_SysClk_PLLDivClk))
|
||
|
||
/**
|
||
* @brief Структура инициализации PLL
|
||
*
|
||
*/
|
||
typedef struct
|
||
{
|
||
uint32_t DivVal; /*!< Значение делителя сигнала на выходе блока PLL (итоговое значение 2*(Div+1)).
|
||
Параметр может принимать любое значение из диапазона 0-63. */
|
||
FunctionalState DivEn; /*!< Активация делителя PLL*/
|
||
RCU_PLL_Ref_TypeDef Ref; /*!< Источник опорного сигнала PLL */
|
||
RCU_PLL_OD_TypeDef OD; /*!< Выходной делитель OD */
|
||
uint32_t M; /*!< Множитель M.
|
||
Параметр может принимать любое значение из диапазона 2-63. */
|
||
uint32_t N; /*!< Делитель N.
|
||
Параметр может принимать любое значение из диапазона 1-63. */
|
||
} RCU_PLL_Init_TypeDef;
|
||
#define IS_RCU_PLL_DIV(VALUE) (((VALUE)&0xFFFFFFC0) == 0)
|
||
#define IS_RCU_PLL_M(VALUE) (((VALUE) <= 63) && ((VALUE) >= 2))
|
||
#define IS_RCU_PLL_N(VALUE) (((VALUE) <= 63) && ((VALUE) >= 1))
|
||
#define IS_RCU_PLL_REF_FREQ(VALUE) (((VALUE) <= 64000000) && ((VALUE) >= 4000000))
|
||
#define IS_RCU_PLL_CMP_FREQ(VALUE) (((VALUE) <= 20000000) && ((VALUE) >= 4000000))
|
||
#define IS_RCU_PLL_VCO_FREQ(VALUE) (((VALUE) <= 200000000) && ((VALUE) >= 120000000))
|
||
|
||
#define IS_RCU_SYSCLK_FREQ(VALUE) (((VALUE) <= 100000000) && ((VALUE) >= 1000000))
|
||
#define IS_RCU_SECPRD(VALUE) (((VALUE)&0xFFFFFF00) == 0)
|
||
#define IS_RCU_OSI_CALIB(VALUE) (((VALUE)&0xFFFFFC00) == 0)
|
||
#define IS_RCU_PERIPH_DIV(VALUE) (((VALUE)&0xFFFFFFC0) == 0)
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_Exported_Functions Функции
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Включение тактирования выбранного APB блока периферии
|
||
* @param APBClk Выбор периферии. Любая совокупность значений значений RCU_APBClk_x (@ref RCU_APBClk_Define).
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_APBClkCmd(uint32_t APBClk, FunctionalState State)
|
||
{
|
||
assert_param(IS_RCU_APB_CLK(APBClk));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->PCLKCFG, APBClk, State ? APBClk : 0);
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования выбранного AHB блока периферии
|
||
* @param AHBClk Выбор периферии. Любая совокупность значений значений RCU_AHBClk_x (@ref RCU_AHBClk_Define).
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_AHBClkCmd(uint32_t AHBClk, FunctionalState State)
|
||
{
|
||
assert_param(IS_RCU_AHB_CLK(AHBClk));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->HCLKCFG, AHBClk, State ? AHBClk : 0);
|
||
}
|
||
|
||
/**
|
||
* @brief Вывод из состояния сброса периферийных блоков APB
|
||
* @param APBRst Выбор периферийного модуля. Любая совокупность значений значений RCU_APBRst_x (@ref RCU_APBRst_Define).
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_APBRstCmd(uint32_t APBRst, FunctionalState State)
|
||
{
|
||
assert_param(IS_RCU_APB_RST(APBRst));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->PRSTCFG, APBRst, State ? APBRst : 0);
|
||
}
|
||
|
||
/**
|
||
* @brief Вывод из состояния сброса периферийных блоков APB
|
||
* @param AHBRst Выбор периферийного модуля. Любая совокупность значений значений RCU_AHBRst_x (@ref RCU_AHBRst_Define).
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_AHBRstCmd(uint32_t AHBRst, FunctionalState State)
|
||
{
|
||
assert_param(IS_RCU_AHB_RST(AHBRst));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->HRSTCFG, AHBRst, State ? AHBRst : 0);
|
||
}
|
||
|
||
/**
|
||
* @brief Установка опорного тактового сигнала для системной частоты
|
||
* @param SysClk Выбор тактового сигнала
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SysClkConfig(RCU_SysClk_TypeDef SysClk)
|
||
{
|
||
assert_param(IS_RCU_SYS_CLK(SysClk));
|
||
|
||
WRITE_REG(RCU->SYSCLKCFG_bit.SYSSEL, SysClk);
|
||
}
|
||
|
||
/**
|
||
* @brief Получение текущего опорного тактового сигнала для системной частоты
|
||
* @retval Val Выбранный сигнал
|
||
*/
|
||
__STATIC_INLINE RCU_SysClk_TypeDef RCU_SysClkStatus(void)
|
||
{
|
||
return (RCU_SysClk_TypeDef)READ_REG(RCU->SYSCLKSTAT_bit.SYSSTAT);
|
||
}
|
||
|
||
/**
|
||
* @brief Получение статуса занятости менеджера тактовых сигналов
|
||
* @retval Status Статус
|
||
*/
|
||
__STATIC_INLINE FlagStatus RCU_BusyStatus(void)
|
||
{
|
||
return (FlagStatus)READ_BIT(RCU->SYSCLKSTAT, RCU_SYSCLKSTAT_BUSY_Msk);
|
||
}
|
||
|
||
/**
|
||
* @brief Получение статуса выбранного тактового сигнала
|
||
* @param ClkStatus Выбор тактового сигнала. Любая совокупность значений значений RCU_ClkStatus_x (@ref RCU_ClkStatus_Define).
|
||
* @retval Status Статус
|
||
*/
|
||
__STATIC_INLINE FlagStatus RCU_ClkStatus(uint32_t ClkStatus)
|
||
{
|
||
return (FlagStatus)READ_BIT(RCU->SYSCLKSTAT, ClkStatus);
|
||
}
|
||
|
||
uint32_t RCU_GetOSIClkFreq(void);
|
||
uint32_t RCU_GetOSEClkFreq(void);
|
||
uint32_t RCU_GetPLLClkFreq(void);
|
||
uint32_t RCU_GetPLLDivClkFreq(void);
|
||
uint32_t RCU_GetSysClkFreq(void);
|
||
|
||
/**
|
||
* @brief Включение системы слежения за системным тактовым сигналом
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SecurityCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->SYSCLKCFG_bit.SECEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Настройка периода срабатывания системы слежения
|
||
* @param OSEPrd Максимальное значение счетчика слежения за сигналом OSECLK
|
||
* @param PLLPrd Максимальное значение счетчика слежения за сигналом PLLCLK
|
||
* @param PLLDivPrd Максимальное значение счетчика слежения за сигналом PLLDIVCLK
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SecurityConfig(uint32_t OSEPrd, uint32_t PLLPrd, uint32_t PLLDivPrd)
|
||
{
|
||
assert_param(IS_RCU_SECPRD(OSEPrd));
|
||
assert_param(IS_RCU_SECPRD(PLLPrd));
|
||
assert_param(IS_RCU_SECPRD(PLLDivPrd));
|
||
|
||
MODIFY_REG(RCU->SECPRD, (RCU_SECPRD_OSECLK_Msk | RCU_SECPRD_PLLCLK_Msk | RCU_SECPRD_PLLDIVCLK_Msk),
|
||
((OSEPrd << RCU_SECPRD_OSECLK_Pos) | (PLLPrd << RCU_SECPRD_PLLCLK_Pos) | (PLLDivPrd << RCU_SECPRD_PLLDIVCLK_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Получение статуса выбранного типа сброса
|
||
* @param RstStatus Выбранный тип сброса. Любая совокупность значений значений RCU_RstStatus_x (@ref RCU_RstStatus_Define).
|
||
* @retval Status Статус активности
|
||
*/
|
||
__STATIC_INLINE FlagStatus RCU_RstStatus(uint32_t RstStatus)
|
||
{
|
||
return (FlagStatus)READ_BIT(RCU->SYSRSTSTAT, RstStatus);
|
||
}
|
||
|
||
/**
|
||
* @brief Очистка статуса выбранного типа сброса
|
||
* @param RstStatus Выбранный тип сброса. Любая совокупность значений значений RCU_RstStatus_x (@ref RCU_RstStatus_Define).
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_RstStatusClear(uint32_t RstStatus)
|
||
{
|
||
assert_param(IS_RCU_RST_STATUS(RstStatus));
|
||
|
||
WRITE_REG(RCU->SYSRSTSTAT, RstStatus);
|
||
}
|
||
|
||
/**
|
||
* @brief Включение сброса ядра по переходу в состояние LockUp
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_LockUpRstCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->SYSRSTCFG_bit.LOCKUPEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Установка калибровочного значения для внутреннего осциллятора
|
||
* @param CalibVal Значение калибровки
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_OSIConfig(uint32_t CalibVal)
|
||
{
|
||
assert_param(IS_RCU_OSI_CALIB(CalibVal));
|
||
|
||
WRITE_REG(RCU->OSICFG_bit.CAL, CalibVal);
|
||
}
|
||
|
||
/**
|
||
* @brief Разрешение работы внешнего осциллятора
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_OSECmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->OSECFG, (RCU_OSECFG_EN_Msk | RCU_OSECFG_XOEN_Msk),
|
||
((State << RCU_OSECFG_EN_Pos) | (State << RCU_OSECFG_XOEN_Pos)));
|
||
}
|
||
|
||
OperationStatus RCU_SysClkChangeCmd(RCU_SysClk_TypeDef SysClk);
|
||
|
||
/** @defgroup RCU_Init_Deinit Конфигурация PLL
|
||
* @{
|
||
*/
|
||
|
||
OperationStatus RCU_PLL_AutoConfig(uint32_t SysClkFreq, RCU_PLL_Ref_TypeDef Ref);
|
||
OperationStatus RCU_PLL_Init(RCU_PLL_Init_TypeDef* InitStruct);
|
||
void RCU_PLL_DeInit(void);
|
||
void RCU_PLL_StructInit(RCU_PLL_Init_TypeDef* InitStruct);
|
||
|
||
/**
|
||
* @brief Разрешение работы выхода PLL
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_PLL_OutCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->PLLCFG_bit.OUTEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Включение режима bypass PLL
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_PLL_BypassCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->PLLCFG_bit.BYPASS, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Настройка внешнего делителя PLL
|
||
* @param Val Выбор значения делителя. Тактовый сигнал делится на Val+1.
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_PLL_DivConfig(uint32_t Val, FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
assert_param(IS_RCU_PLL_DIV(Val));
|
||
|
||
MODIFY_REG(RCU->PLLDIV, RCU_PLLDIV_DIV_Msk | RCU_PLLDIV_DIVEN_Msk,
|
||
(Val << RCU_PLLDIV_DIV_Pos |
|
||
State << RCU_PLLDIV_DIVEN_Pos));
|
||
}
|
||
|
||
/**
|
||
* @brief Получение статуса захвата частоты PLL
|
||
* @retval Status Статус захвата
|
||
*/
|
||
__STATIC_INLINE FlagStatus RCU_PLL_LockStatus(void)
|
||
{
|
||
return (FlagStatus)READ_BIT(RCU->PLLCFG, RCU_PLLCFG_LOCK_Msk);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_Config_ClkOut Настройка выдачи тактового сигнала CLKOUT
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetClkOutFreq(void);
|
||
|
||
/**
|
||
* @brief Настройка тактирования ClkOut
|
||
* @param ClkOut Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ClkOutConfig(RCU_SysPeriphClk_TypeDef ClkOut, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_SYS_PERIPH_CLK(ClkOut));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->CLKOUTCFG, (RCU_CLKOUTCFG_CLKSEL_Msk | RCU_CLKOUTCFG_DIVN_Msk | RCU_CLKOUTCFG_DIVEN_Msk),
|
||
((ClkOut << RCU_CLKOUTCFG_CLKSEL_Pos) | (DivVal << RCU_CLKOUTCFG_DIVN_Pos) | (DivState << RCU_CLKOUTCFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования ClkOut
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ClkOutCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->CLKOUTCFG_bit.CLKEN, State);
|
||
WRITE_REG(SIU->CLKOUTCTL_bit.CLKOUTEN, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_Config_Trace Тактирование модуля трассировки
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetTraceClkFreq(void);
|
||
|
||
/**
|
||
* @brief Настройка тактирования блока трассировки
|
||
* @param TraceClk Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_TraceClkConfig(RCU_SysPeriphClk_TypeDef TraceClk, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_SYS_PERIPH_CLK(TraceClk));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->TRACECFG, (RCU_TRACECFG_CLKSEL_Msk | RCU_TRACECFG_DIVN_Msk | RCU_TRACECFG_DIVEN_Msk),
|
||
((TraceClk << RCU_TRACECFG_CLKSEL_Pos) | (DivVal << RCU_TRACECFG_DIVN_Pos) | (DivState << RCU_TRACECFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования трассировки
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_TraceClkCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->TRACECFG_bit.CLKEN, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_RST_Config_UART Тактирование и сброс UART
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetUARTClkFreq(UART_Num_TypeDef UARTx_Num);
|
||
|
||
/**
|
||
* @brief Настройка тактирования UART
|
||
* @param UARTx_Num Порядковый номер блока UART
|
||
* @param UARTClk Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_UARTClkConfig(UART_Num_TypeDef UARTx_Num, RCU_PeriphClk_TypeDef UARTClk, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_PERIPH_CLK(UARTClk));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->UARTCFG[UARTx_Num].UARTCFG, (RCU_UARTCFG_UARTCFG_CLKSEL_Msk | RCU_UARTCFG_UARTCFG_DIVN_Msk | RCU_UARTCFG_UARTCFG_DIVEN_Msk),
|
||
((UARTClk << RCU_UARTCFG_UARTCFG_CLKSEL_Pos) | (DivVal << RCU_UARTCFG_UARTCFG_DIVN_Pos) | (DivState << RCU_UARTCFG_UARTCFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования UART
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_UARTClkCmd(UART_Num_TypeDef UARTx_Num, FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->UARTCFG[UARTx_Num].UARTCFG_bit.CLKEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Cнятие сброса UART
|
||
* @param UARTx_Num Порядковый номер блока UART
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_UARTRstCmd(UART_Num_TypeDef UARTx_Num, FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->UARTCFG[UARTx_Num].UARTCFG_bit.RSTDIS, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_RST_Config_SPI Тактирование и сброс SPI
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetSPIClkFreq(void);
|
||
|
||
/**
|
||
* @brief Настройка тактирования SPI
|
||
* @param SPIClk Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SPIClkConfig(RCU_PeriphClk_TypeDef SPIClk, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_PERIPH_CLK(SPIClk));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->SPICFG, (RCU_SPICFG_CLKSEL_Msk | RCU_SPICFG_DIVN_Msk | RCU_SPICFG_DIVEN_Msk),
|
||
((SPIClk << RCU_SPICFG_CLKSEL_Pos) | (DivVal << RCU_SPICFG_DIVN_Pos) | (DivState << RCU_SPICFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования SPI
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SPIClkCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->SPICFG_bit.CLKEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Cнятие сброса SPI
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_SPIRstCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->SPICFG_bit.RSTDIS, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_RST_Config_WDT Тактирование и сброс WDT
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetWDTClkFreq(void);
|
||
|
||
/**
|
||
* @brief Настройка тактирования сторожевого таймера
|
||
* @param WDTClk Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_WDTClkConfig(RCU_SysPeriphClk_TypeDef WDTClk, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_SYS_PERIPH_CLK(WDTClk));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->WDTCFG, (RCU_WDTCFG_CLKSEL_Msk | RCU_WDTCFG_DIVN_Msk | RCU_WDTCFG_DIVEN_Msk),
|
||
((WDTClk << RCU_WDTCFG_CLKSEL_Pos) | (DivVal << RCU_WDTCFG_DIVN_Pos) | (DivState << RCU_WDTCFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования сторожевого таймера
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_WDTClkCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->WDTCFG_bit.CLKEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Cнятие сброса сторожевого таймера
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_WDTRstCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->WDTCFG_bit.RSTDIS, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_CLK_RST_Config_ADC Тактирование и сброс ADC
|
||
* @{
|
||
*/
|
||
|
||
uint32_t RCU_GetADCClkFreq(void);
|
||
|
||
/**
|
||
* @brief Настройка тактирования АЦП
|
||
* @param ADCClk Источник тактового сигнала
|
||
* @param DivVal Значение делителя (деление на 2*(DivVal+1))
|
||
* @param DivState Разрешение работы делителя
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ADCClkConfig(RCU_PeriphClk_TypeDef ADCClk, uint32_t DivVal, FunctionalState DivState)
|
||
{
|
||
assert_param(IS_RCU_PERIPH_CLK(ADCClk));
|
||
assert_param(IS_RCU_PERIPH_DIV(DivVal));
|
||
assert_param(IS_FUNCTIONAL_STATE(DivState));
|
||
|
||
MODIFY_REG(RCU->ADCCFG, (RCU_ADCCFG_CLKSEL_Msk | RCU_ADCCFG_DIVN_Msk | RCU_ADCCFG_DIVEN_Msk),
|
||
((ADCClk << RCU_ADCCFG_CLKSEL_Pos) | (DivVal << RCU_ADCCFG_DIVN_Pos) | (DivState << RCU_ADCCFG_DIVEN_Pos)));
|
||
}
|
||
|
||
/**
|
||
* @brief Включение тактирования АЦП
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ADCClkCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->ADCCFG_bit.CLKEN, State);
|
||
}
|
||
|
||
/**
|
||
* @brief Cнятие сброса АЦП
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ADCRstCmd(FunctionalState State)
|
||
{
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
WRITE_REG(RCU->ADCCFG_bit.RSTDIS, State);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/** @defgroup RCU_IT Прерывания
|
||
* @{
|
||
*/
|
||
|
||
/**
|
||
* @brief Разрешение работы прерывания RCU
|
||
* @param ITSource Выбор источника прерывания. Любая совокупность значений значений RCU_ITSource_x (@ref RCU_ITSource_Define).
|
||
* @param State Выбор состояния
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ITCmd(uint32_t ITSource, FunctionalState State)
|
||
{
|
||
assert_param(IS_RCU_IT_SOURCE(ITSource));
|
||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||
|
||
MODIFY_REG(RCU->INTEN, ITSource, State ? (uint32_t)ITSource : 0);
|
||
}
|
||
|
||
/**
|
||
* @brief Получение статуса выбранного флага прерывания
|
||
* @param ITStatus Выбранный флаг. Любая совокупность значений значений RCU_ITStatus_x (@ref RCU_ITStatus_Define).
|
||
* @retval Status Статус
|
||
*/
|
||
__STATIC_INLINE FlagStatus RCU_ITStatus(uint32_t ITStatus)
|
||
{
|
||
assert_param(IS_RCU_IT_STATUS(ITStatus));
|
||
|
||
return (FlagStatus)READ_BIT(RCU->INTSTAT, ITStatus);
|
||
}
|
||
|
||
/**
|
||
* @brief Сброс статуса выбранного флага прерывания
|
||
* @param ITStatus Выбранный флаг. Любая совокупность значений значений RCU_ITStatus_x (@ref RCU_ITStatus_Define).
|
||
* @retval void
|
||
*/
|
||
__STATIC_INLINE void RCU_ITStatusClear(uint32_t ITStatus)
|
||
{
|
||
assert_param(IS_RCU_IT_STATUS(ITStatus));
|
||
|
||
WRITE_REG(RCU->INTSTAT, ITStatus);
|
||
}
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __PLIB035_RCU_H */
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/**
|
||
* @}
|
||
*/
|
||
|
||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|