Проект перенесен в папку MDK-ARM
This commit is contained in:
145
MDK-ARM/platform/plib035/inc/plib035.h
Normal file
145
MDK-ARM/platform/plib035/inc/plib035.h
Normal file
@@ -0,0 +1,145 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035.h
|
||||
*
|
||||
* @brief Низкоуровневая библиотека периферии для микроконтроллера НИИЭТ К1921ВК035
|
||||
* Этот файл содержит:
|
||||
* - Главный заголовочный файл целевого устройства, с описанием всех регистров его периферии
|
||||
* - Область настройки драйвера
|
||||
* - Макросы для доступа к регистрам периферии
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/** @addtogroup PLib035 Библиотека периферии
|
||||
* @{
|
||||
*/
|
||||
|
||||
#ifndef __PLIB035_H
|
||||
#define __PLIB035_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "K1921VK035.h"
|
||||
|
||||
/** @addtogroup Exported_macro Макросы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#if defined(__ICCARM__)
|
||||
#define __RAMFUNC __ramfunc
|
||||
#elif defined(__CMCARM__)
|
||||
#define __RAMFUNC __ramfunc
|
||||
#elif defined(__CC_ARM)
|
||||
#define __RAMFUNC
|
||||
#elif defined(__GNUC__)
|
||||
#define __RAMFUNC __attribute__((long_call, section(".ramfunc")))
|
||||
#else
|
||||
#error "plib035.h: RAMFUNC - нет реализации под данный компилятор!"
|
||||
#endif
|
||||
|
||||
#define SET_BIT(REG, BIT) ((REG) |= (BIT))
|
||||
|
||||
#define CLEAR_BIT(REG, BIT) ((REG) &= ~(BIT))
|
||||
|
||||
#define READ_BIT(REG, BIT) (((REG) & (BIT)) ? (0x1) : (0x0))
|
||||
|
||||
#define CLEAR_REG(REG) ((REG) = (0x0))
|
||||
|
||||
#define WRITE_REG(REG, VAL) ((REG) = (VAL))
|
||||
|
||||
#define READ_REG(REG) ((REG))
|
||||
|
||||
#define MODIFY_REG(REG, CLEARMASK, SETMASK) WRITE_REG((REG), (((READ_REG(REG)) & (~(CLEARMASK))) | (SETMASK)))
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @addtogroup Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Описывает логическое состояние периферии.
|
||||
* Используется для операций включения/выключения периферийных блоков или их функций.
|
||||
*/
|
||||
typedef enum {
|
||||
DISABLE = 0UL,
|
||||
ENABLE = 1UL
|
||||
} FunctionalState;
|
||||
#define IS_FUNCTIONAL_STATE(VALUE) (((VALUE) == DISABLE) || ((VALUE) == ENABLE))
|
||||
|
||||
/**
|
||||
* @brief Описывает коды возврата при выполнении какой-либо операции
|
||||
*/
|
||||
typedef enum {
|
||||
OK = 0UL,
|
||||
ERROR = 1UL
|
||||
} OperationStatus;
|
||||
|
||||
/**
|
||||
* @brief Описывает возможные состояния флага или бита
|
||||
*/
|
||||
typedef enum {
|
||||
CLEAR = 0UL,
|
||||
SET = 1UL
|
||||
} FlagStatus,
|
||||
BitState;
|
||||
#define IS_BIT_STATE(VALUE) (((VALUE) == CLEAR) || ((VALUE) == SET))
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup Misc Дополнительные модули
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "plib035_assert.h"
|
||||
#include "plib035_version.h"
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @addtogroup Peripheral Периферия
|
||||
* @{
|
||||
*/
|
||||
|
||||
#include "plib035_conf.h"
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
1155
MDK-ARM/platform/plib035/inc/plib035_adc.h
Normal file
1155
MDK-ARM/platform/plib035/inc/plib035_adc.h
Normal file
@@ -0,0 +1,1155 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_adc.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* ADC, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_ADC_H
|
||||
#define __PLIB035_ADC_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ADC
|
||||
* @brief Драйвер для работы с ADC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define ADC_SEQ_Total 2UL
|
||||
#define ADC_SEQ_Req_Total 4UL
|
||||
#define ADC_DC_Total 4UL
|
||||
#define ADC_CH_Total 4UL
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Номер секвенсора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_SEQ_Num_0, /*!< Севенсор 0 */
|
||||
ADC_SEQ_Num_1 /*!< Севенсор 1 */
|
||||
} ADC_SEQ_Num_TypeDef;
|
||||
#define IS_ADC_SEQ_NUM(VALUE) (((VALUE) == ADC_SEQ_Num_0) || \
|
||||
((VALUE) == ADC_SEQ_Num_1))
|
||||
|
||||
/**
|
||||
* @brief Номер запроса в очереди секвенсора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_SEQ_ReqNum_0, /*!< Запрос 0 */
|
||||
ADC_SEQ_ReqNum_1, /*!< Запрос 1 */
|
||||
ADC_SEQ_ReqNum_2, /*!< Запрос 2 */
|
||||
ADC_SEQ_ReqNum_3 /*!< Запрос 3 */
|
||||
} ADC_SEQ_ReqNum_TypeDef;
|
||||
#define IS_ADC_SEQ_REQ_NUM(VALUE) (((VALUE) == ADC_SEQ_ReqNum_0) || \
|
||||
((VALUE) == ADC_SEQ_ReqNum_1) || \
|
||||
((VALUE) == ADC_SEQ_ReqNum_2) || \
|
||||
((VALUE) == ADC_SEQ_ReqNum_3))
|
||||
|
||||
/**
|
||||
* @brief События запуска секвенсоров
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_SEQ_StartEvent_SwReq = ADC_EMUX_EM0_SwReq, /*!< Запуск по программному запросу */
|
||||
ADC_SEQ_StartEvent_GPIOA = ADC_EMUX_EM0_GPIOA, /*!< Сигнал от GPIOA */
|
||||
ADC_SEQ_StartEvent_GPIOB = ADC_EMUX_EM0_GPIOB, /*!< Сигнал от GPIOB */
|
||||
ADC_SEQ_StartEvent_TMR0 = ADC_EMUX_EM0_TMR0, /*!< Сигнал от таймера 0 */
|
||||
ADC_SEQ_StartEvent_TMR1 = ADC_EMUX_EM0_TMR1, /*!< Сигнал от таймера 1 */
|
||||
ADC_SEQ_StartEvent_TMR2 = ADC_EMUX_EM0_TMR2, /*!< Сигнал от таймера 2 */
|
||||
ADC_SEQ_StartEvent_TMR3 = ADC_EMUX_EM0_TMR3, /*!< Сигнал от таймера 3 */
|
||||
ADC_SEQ_StartEvent_PWM012A = ADC_EMUX_EM0_PWM012A, /*!< Сигналы A от блоков ШИМ 0, 1, 2 */
|
||||
ADC_SEQ_StartEvent_PWM012B = ADC_EMUX_EM0_PWM012B, /*!< Сигналы B от блоков ШИМ 0, 1, 2 */
|
||||
ADC_SEQ_StartEvent_Cycle = ADC_EMUX_EM0_Cycle, /*!< Циклическая работа сразу после запуска секвенсора */
|
||||
} ADC_SEQ_StartEvent_TypeDef;
|
||||
#define IS_ADC_SEQ_START_EVENT(VALUE) (((VALUE) == ADC_SEQ_StartEvent_SwReq) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_GPIOA) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_GPIOB) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_TMR0) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_TMR1) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_TMR2) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_TMR3) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_PWM012A) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_PWM012B) || \
|
||||
((VALUE) == ADC_SEQ_StartEvent_Cycle))
|
||||
|
||||
/**
|
||||
* @brief Количество измерений для усреднения
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_SEQ_Average_2 = ADC_SEQ_SRQCTL_QAVGVAL_Average2, /*!< Усреднение по 2 измерениям */
|
||||
ADC_SEQ_Average_4 = ADC_SEQ_SRQCTL_QAVGVAL_Average4, /*!< Усреднение по 4 измерениям */
|
||||
ADC_SEQ_Average_8 = ADC_SEQ_SRQCTL_QAVGVAL_Average8, /*!< Усреднение по 8 измерениям */
|
||||
ADC_SEQ_Average_16 = ADC_SEQ_SRQCTL_QAVGVAL_Average16, /*!< Усреднение по 16 измерениям */
|
||||
ADC_SEQ_Average_32 = ADC_SEQ_SRQCTL_QAVGVAL_Average32, /*!< Усреднение по 32 измерениям */
|
||||
ADC_SEQ_Average_64 = ADC_SEQ_SRQCTL_QAVGVAL_Average64, /*!< Усреднение по 64 измерениям */
|
||||
} ADC_SEQ_Average_TypeDef;
|
||||
#define IS_ADC_SEQ_AVERAGE(VALUE) (((VALUE) == ADC_SEQ_Average_2) || \
|
||||
((VALUE) == ADC_SEQ_Average_4) || \
|
||||
((VALUE) == ADC_SEQ_Average_8) || \
|
||||
((VALUE) == ADC_SEQ_Average_16) || \
|
||||
((VALUE) == ADC_SEQ_Average_32) || \
|
||||
((VALUE) == ADC_SEQ_Average_64))
|
||||
|
||||
/**
|
||||
* @brief Количество результатов измерений записанных в буфер секвенсора, по достижению которого вызывается DMA
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_SEQ_DMAFIFOLevel_1 = ADC_SEQ_SDMACTL_WMARK_Level1, /*!< Запрос DMA после заполнения 1 ячейки в буффере */
|
||||
ADC_SEQ_DMAFIFOLevel_2 = ADC_SEQ_SDMACTL_WMARK_Level2, /*!< Запрос DMA после заполнения 2 ячеек в буффере */
|
||||
ADC_SEQ_DMAFIFOLevel_4 = ADC_SEQ_SDMACTL_WMARK_Level4, /*!< Запрос DMA после заполнения 4 ячеек в буффере */
|
||||
ADC_SEQ_DMAFIFOLevel_8 = ADC_SEQ_SDMACTL_WMARK_Level8, /*!< Запрос DMA после заполнения 8 ячеек в буффере */
|
||||
ADC_SEQ_DMAFIFOLevel_16 = ADC_SEQ_SDMACTL_WMARK_Level16, /*!< Запрос DMA после заполнения 16 ячеек в буффере */
|
||||
ADC_SEQ_DMAFIFOLevel_32 = ADC_SEQ_SDMACTL_WMARK_Level32, /*!< Запрос DMA после заполнения 32 ячеек в буффере */
|
||||
} ADC_SEQ_DMAFIFOLevel_TypeDef;
|
||||
#define IS_ADC_SEQ_DMA_FIFO_LEVEL(VALUE) (((VALUE) == ADC_SEQ_DMAFIFOLevel_1) || \
|
||||
((VALUE) == ADC_SEQ_DMAFIFOLevel_2) || \
|
||||
((VALUE) == ADC_SEQ_DMAFIFOLevel_4) || \
|
||||
((VALUE) == ADC_SEQ_DMAFIFOLevel_8) || \
|
||||
((VALUE) == ADC_SEQ_DMAFIFOLevel_16) || \
|
||||
((VALUE) == ADC_SEQ_DMAFIFOLevel_32))
|
||||
|
||||
/**
|
||||
* @brief Номер цифрового компаратора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_DC_Num_0, /*!< Модуль цифрового компаратора 0 */
|
||||
ADC_DC_Num_1, /*!< Модуль цифрового компаратора 1 */
|
||||
ADC_DC_Num_2, /*!< Модуль цифрового компаратора 2 */
|
||||
ADC_DC_Num_3, /*!< Модуль цифрового компаратора 3 */
|
||||
} ADC_DC_Num_TypeDef;
|
||||
#define IS_ADC_DC_NUM(VALUE) (((VALUE) == ADC_DC_Num_0) || \
|
||||
((VALUE) == ADC_DC_Num_1) || \
|
||||
((VALUE) == ADC_DC_Num_2) || \
|
||||
((VALUE) == ADC_DC_Num_3))
|
||||
|
||||
/**
|
||||
* @brief Режим срабатывания цифрового компаратора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_DC_Mode_Multiple = ADC_DC_DCTL_CIM_Multiple, /*!< Многократный */
|
||||
ADC_DC_Mode_Single = ADC_DC_DCTL_CIM_Single, /*!< Однократный */
|
||||
ADC_DC_Mode_MultipleHyst = ADC_DC_DCTL_CIM_MultipleHyst, /*!< Многократный с гистерезисом */
|
||||
ADC_DC_Mode_SingleHyst = ADC_DC_DCTL_CIM_SingleHyst, /*!< Однократный с гистерезисом */
|
||||
} ADC_DC_Mode_TypeDef;
|
||||
#define IS_ADC_DC_MODE(VALUE) (((VALUE) == ADC_DC_Mode_Single) || \
|
||||
((VALUE) == ADC_DC_Mode_Multiple) || \
|
||||
((VALUE) == ADC_DC_Mode_SingleHyst) || \
|
||||
((VALUE) == ADC_DC_Mode_MultipleHyst))
|
||||
|
||||
/**
|
||||
* @brief Условие срабатывания компаратора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_DC_Condition_Low = ADC_DC_DCTL_CIC_Low, /*!< Результат меньше либо равен нижней границе */
|
||||
ADC_DC_Condition_Window = ADC_DC_DCTL_CIC_Window, /*!< Результат внутри диапазона, задаваемого границами, либо равен одной из них */
|
||||
ADC_DC_Condition_High = ADC_DC_DCTL_CIC_High, /*!< Результат больше либо равен верхней границе */
|
||||
} ADC_DC_Condition_TypeDef;
|
||||
#define IS_ADC_DC_CONDITION(VALUE) (((VALUE) == ADC_DC_Condition_Low) || \
|
||||
((VALUE) == ADC_DC_Condition_Window) || \
|
||||
((VALUE) == ADC_DC_Condition_High))
|
||||
|
||||
/**
|
||||
* @brief Источник данных для компаратора
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_DC_Source_EOC, /*!< Ококнчание измерения АЦП */
|
||||
ADC_DC_Source_FIFO, /*!< Запись результатат в FIFO */
|
||||
} ADC_DC_Source_TypeDef;
|
||||
#define IS_ADC_DC_SOURCE(VALUE) (((VALUE) == ADC_DC_Source_EOC) || \
|
||||
((VALUE) == ADC_DC_Source_FIFO))
|
||||
|
||||
/**
|
||||
* @brief Номер канала
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_CH_Num_0, /*!< Канал 0 */
|
||||
ADC_CH_Num_1, /*!< Канал 1 */
|
||||
ADC_CH_Num_2, /*!< Канал 2 */
|
||||
ADC_CH_Num_3, /*!< Канал 3 */
|
||||
} ADC_CH_Num_TypeDef;
|
||||
#define IS_ADC_CH_NUM(VALUE) (((VALUE) == ADC_CH_Num_0) || \
|
||||
((VALUE) == ADC_CH_Num_1) || \
|
||||
((VALUE) == ADC_CH_Num_2) || \
|
||||
((VALUE) == ADC_CH_Num_3))
|
||||
|
||||
/**
|
||||
* @brief Выбор приоритета канала
|
||||
*/
|
||||
typedef enum {
|
||||
ADC_CH_Priority_Normal, /*!< Обычный уровень приоритета */
|
||||
ADC_CH_Priority_High, /*!< Высокий уровень приоритета */
|
||||
} ADC_CH_Priority_TypeDef;
|
||||
#define IS_ADC_CH_PRIORITY(VALUE) (((VALUE) == ADC_CH_Priority_Normal) || \
|
||||
((VALUE) == ADC_CH_Priority_High))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации цифровых компараторов
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState DCOutput; /*!< Разрешает работу выходному триггеру компаратора */
|
||||
uint32_t ThresholdLow; /*!< Нижний порог срабатывания компаратора.
|
||||
Параметр может принимать любое значение из диапазона 0 - 4095. */
|
||||
uint32_t ThresholdHigh; /*!< Верхний порог срабатывания компаратора.
|
||||
Параметр может принимать любое значение из диапазона 0 - 4095. */
|
||||
ADC_DC_Source_TypeDef Source; /*!< Выбирает источник получения измерения */
|
||||
ADC_CH_Num_TypeDef Channel; /*!< Выбирает канал, результат измерения которого будет передан на компаратор */
|
||||
ADC_DC_Mode_TypeDef Mode; /*!< Выбирает режим срабатывания компаратора */
|
||||
ADC_DC_Condition_TypeDef Condition; /*!< Выбирает условие срабатывания компаратора */
|
||||
} ADC_DC_Init_TypeDef;
|
||||
|
||||
#define IS_ADC_DC_THRESHOLD(VALUE) ((VALUE) < 0x1000)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации секвенсоров
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_SEQ_StartEvent_TypeDef StartEvent; /*!< Определяет cобытие запуска секвенсора */
|
||||
FunctionalState SWStartEn; /*!< Разрешает секвенсору запускаться по программному запросу */
|
||||
ADC_CH_Num_TypeDef Req[ADC_SEQ_Req_Total]; /*!< Выбор каналов для запросов секвенсора */
|
||||
ADC_SEQ_ReqNum_TypeDef ReqMax; /*!< Настройка глубины очереди запросов */
|
||||
ADC_SEQ_Average_TypeDef ReqAverage; /*!< Настройка усреднения сканированием очереди запросов */
|
||||
FunctionalState ReqAverageEn; /*!< Разрешение усреднения сканированием очереди запросов */
|
||||
uint32_t RestartCount; /*!< Задание количества перезапусков модулей АЦП секвенсором после его запуска по событию.
|
||||
0x00 - без перезапусков, 0x01 - 1 перезапуск, 0xFF - 255 перезапусков. */
|
||||
FunctionalState RestartAverageEn; /*!< Разрешение усреднения по перезапускам */
|
||||
uint32_t RestartTimer; /*!< Задание задержки запуска модуля АЦП.
|
||||
Параметр может принимать любое значение из диапазона 0x00000000 - 0x00FFFFFF. */
|
||||
FunctionalState DCEn[ADC_DC_Total]; /*!< Разрешение работы цифровых компараторов секвенсором */
|
||||
ADC_SEQ_DMAFIFOLevel_TypeDef DMAFIFOLevel; /*!< Настройка уровня заполненности буфера для генерации запросов DMA */
|
||||
FunctionalState DMAEn; /*!< Разрешение генерации запросов DMA */
|
||||
} ADC_SEQ_Init_TypeDef;
|
||||
|
||||
#define IS_ADC_SEQ_RESTART_VAL(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_ADC_SEQ_RESTART_TIMER_VAL(VALUE) ((VALUE) < 0x1000000)
|
||||
#define IS_ADC_SEQ_IT_COUNT_VAL(VALUE) ((VALUE) < 0x100)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ADC_DeInit(void);
|
||||
|
||||
/**
|
||||
* @brief Включение аналогового модуля АЦП
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_AM_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->ACTL_bit.ADCEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса готовности аналогового модуля АЦП. Флаг становится активным после того,
|
||||
* как модуль АЦП провел внутренние процедуры иницализации.
|
||||
* @retval Status Статус готовности
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_AM_ReadyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_REG(ADC->ACTL_bit.ADCRDY);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса занятости аналогового модуля АЦП. Флаг становится активным при
|
||||
* проведении измерения.
|
||||
* @retval Status Статус занятости
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_AM_BusyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_REG(ADC->BSTAT_bit.ADCBUSY);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка приоритета канала АЦП
|
||||
* @param Channel_Num Выбор канала
|
||||
* @param Priority Выбор приоритета
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_CH_PriorityConfig(ADC_CH_Num_TypeDef Channel_Num, ADC_CH_Priority_TypeDef Priority)
|
||||
{
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
assert_param(IS_ADC_CH_PRIORITY(Priority));
|
||||
|
||||
WRITE_REG(ADC->CHCTL[Channel_Num].CHCTL_bit.PRIORITY, Priority);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения коэффициента коррекции ошибки усиления
|
||||
* @param Channel_Num Выбор канала
|
||||
* @retval Val Значение. Диапазон значений -256…255, величина в
|
||||
дополнительном коде: 100h соответствует -256, 000h - 0, 0FFh - 255.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_CH_GetGainTrim(ADC_CH_Num_TypeDef Channel_Num)
|
||||
{
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
return READ_REG(ADC->CHCTL[Channel_Num].CHCTL_bit.GAINTRIM);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения коэффициента коррекции ошибки усиления
|
||||
* @param Channel_Num Выбор канала
|
||||
* @param Val Значение. Диапазон значений -256…255, величина в
|
||||
дополнительном коде: 100h соответствует -256, 000h - 0, 0FFh - 255.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_CH_SetGainTrim(ADC_CH_Num_TypeDef Channel_Num, uint32_t Val)
|
||||
{
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
WRITE_REG(ADC->CHCTL[Channel_Num].CHCTL_bit.GAINTRIM, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения коэффициента коррекции ошибки смещения нуля
|
||||
* @param Channel_Num Выбор канала
|
||||
* @retval Val Значение. Диапазон значений -256…255, величина в
|
||||
дополнительном коде: 100h соответствует -256, 000h - 0, 0FFh - 255.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_CH_GetOffsetTrim(ADC_CH_Num_TypeDef Channel_Num)
|
||||
{
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
return READ_REG(ADC->CHCTL[Channel_Num].CHCTL_bit.OFFTRIM);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения коэффициента коррекции ошибки смещения нуля
|
||||
* @param Channel_Num Выбор канала
|
||||
* @param Val Значение. Диапазон значений -256…255, величина в
|
||||
дополнительном коде: 100h соответствует -256, 000h - 0, 0FFh - 255.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_CH_SetOffsetTrim(ADC_CH_Num_TypeDef Channel_Num, uint32_t Val)
|
||||
{
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
WRITE_REG(ADC->CHCTL[Channel_Num].CHCTL_bit.OFFTRIM, Val);
|
||||
}
|
||||
|
||||
/** @defgroup ADC_Exported_Functions_Init_SEQ Секвенсоры
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ADC_SEQ_Init(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_Init_TypeDef* InitStruct);
|
||||
void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Включение модуля секвенсора АЦП
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_Cmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ADC->SEQEN, 1 << (uint32_t)SEQ_Num, State << (uint32_t)SEQ_Num);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение программного запуска секвенсора АЦП
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_SwStartEnCmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ADC->SEQSYNC, 1 << (uint32_t)SEQ_Num, State << (uint32_t)SEQ_Num);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Генерация импульса программного запуска
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_SwStartCmd(void)
|
||||
{
|
||||
WRITE_REG(ADC->SEQSYNC_bit.GSYNC, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса занятости секвенсора. Флаг становится активным при
|
||||
* проведении запусков/перезапусков.
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Статус занятости
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_BusyStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->BSTAT, 1 << (uint32_t)SEQ_Num);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса заполнения буфера секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Статус заполнения буфера
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_FIFOFullStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_OV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса заполнения буфера секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_FIFOFullStatusClear(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
WRITE_REG(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_OV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса пустоты буфера секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Статус пустоты буфера
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_FIFOEmptyStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_UN0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса пустоты буфера секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_FIFOEmptyStatusClear(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
WRITE_REG(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_UN0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события запуска секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param StartEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_StartEventConfig(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_StartEvent_TypeDef StartEvent)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
MODIFY_REG(ADC->EMUX, 0xF << ((uint32_t)SEQ_Num * 4), StartEvent << ((uint32_t)SEQ_Num * 4));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор каналов для запроса секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param ReqNum Выбор запроса
|
||||
* @param Channel_Num Выбор канала
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ReqConfig(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_ReqNum_TypeDef ReqNum, ADC_CH_Num_TypeDef Channel_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_REQ_NUM(ReqNum));
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
MODIFY_REG(ADC->SEQ[SEQ_Num].SRQSEL, 0x3 << ((uint32_t)ReqNum * 4), Channel_Num << ((uint32_t)ReqNum * 4));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка глубины очереди запросов
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param ReqNumMax Номер последнего запроса
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ReqMaxConfig(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_ReqNum_TypeDef ReqNumMax)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_REQ_NUM(ReqNumMax));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SRQCTL_bit.RQMAX, ReqNumMax);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка усреднения сканированием очереди запросов
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param Average Выбор режима усреднения
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ReqAverageConfig(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_Average_TypeDef Average)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_AVERAGE(Average));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SRQCTL_bit.QAVGVAL, Average);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение усреднения сканированием очереди запросов
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ReqAverageCmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SRQCTL_bit.QAVGEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего номера запроса в очереди
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Номер запроса
|
||||
*/
|
||||
__STATIC_INLINE ADC_SEQ_ReqNum_TypeDef ADC_SEQ_GetReqCurrent(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (ADC_SEQ_ReqNum_TypeDef)READ_REG(ADC->SEQ[SEQ_Num].SRQSTAT_bit.RQPTR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса занятости запроса секвенсора. Флаг становится активным при
|
||||
* выставленном запросе.
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Статус занятости
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_ReqBusyStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_REG(ADC->SEQ[SEQ_Num].SRQSTAT_bit.RQBUSY);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка генерации запросов DMA
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param DMAFIFOLevel Выбор уровня заполнения буфера для генерации запросов DMA
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_DMAConfig(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_DMAFIFOLevel_TypeDef DMAFIFOLevel)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_DMA_FIFO_LEVEL(DMAFIFOLevel));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SDMACTL_bit.WMARK, DMAFIFOLevel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации запросов DMA
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_DMACmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SDMACTL_bit.DMAEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса ошибки генерации запросов DMA
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Статус ошибки
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_DMAErrorStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_DOV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса ошибки генерации запросов DMA
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_DMAErrorStatusClear(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
WRITE_REG(ADC->FSTAT, 1 << ((uint32_t)SEQ_Num + ADC_FSTAT_DOV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества перезапусков очереди запросов
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param RestartVal Количество. 0x00 - без перезапусков,
|
||||
* 0x01 - 1 перезапуск, 0xFF - 255 перезапусков.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_RestartConfig(ADC_SEQ_Num_TypeDef SEQ_Num, uint32_t RestartVal)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_RESTART_VAL(RestartVal));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SCCTL_bit.RCNT, RestartVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение режима усреднения по перезапускам.
|
||||
* При этом количество перезапусков должно равнятся 2^p - 1 (p=1..8).
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_RestartAverageCmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SCCTL_bit.RAVGEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего количества совершенных перезапусков
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Номер запроса
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_SEQ_GetRestartCurrent(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return READ_REG(ADC->SEQ[SEQ_Num].SCVAL_bit.RCNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение поступления данных на выбранный цифровой компаратор
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_DCEnableCmd(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_DC_Num_TypeDef DC_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ADC->SEQ[SEQ_Num].SDC, 1 << ((uint32_t)DC_Num), State << ((uint32_t)DC_Num));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения задержки перезапуска секвенсора в тактак ACLK
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param TimerVal Значение. 0 - означает отсутствие задержки и немедленный перезапуск (если активен).
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_SetRestartTimer(ADC_SEQ_Num_TypeDef SEQ_Num, uint32_t TimerVal)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_RESTART_TIMER_VAL(TimerVal));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SRTMR_bit.VAL, TimerVal);
|
||||
}
|
||||
/**
|
||||
* @brief Получение текущего значения задержки перезапуска секвенсора в тактак ACLK
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Значение. 0 - означает отсутствие задержки и немедленный перезапуск (если активен).
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_SEQ_GetRestartTimer(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return READ_REG(ADC->SEQ[SEQ_Num].SRTMR_bit.VAL);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение обновления значения задержки по событиям перезапуска (по умолчанию, только по запускам)
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_RestartTimerUpdateCmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SRTMR_bit.NOWAIT, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения количества результатов в буфере секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_SEQ_GetFIFOLoad(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return READ_REG(ADC->SEQ[SEQ_Num].SFLOAD_bit.VAL);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение результата измерения из буфера секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_SEQ_GetFIFOData(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return READ_REG(ADC->SEQ[SEQ_Num].SFIFO_bit.DATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Functions_Init_DC Цифровые компараторы
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ADC_DC_Init(ADC_DC_Num_TypeDef DC_Num, ADC_DC_Init_TypeDef* InitStruct);
|
||||
void ADC_DC_StructInit(ADC_DC_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_OutputCmd(ADC_DC_Num_TypeDef DC_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCTL_bit.CTE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка источника данных цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Source Выбор источника
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_SourceConfig(ADC_DC_Num_TypeDef DC_Num, ADC_DC_Source_TypeDef Source)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_DC_SOURCE(Source));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCTL_bit.SRC, Source);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор канала АЦП для получения данных цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Source Выбор источника
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_ChannelConfig(ADC_DC_Num_TypeDef DC_Num, ADC_CH_Num_TypeDef Channel_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_CH_NUM(Channel_Num));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCTL_bit.CHNL, Channel_Num);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима и условия срабатывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Mode Выбор режима
|
||||
* @param Condition Выбор условия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_Config(ADC_DC_Num_TypeDef DC_Num, ADC_DC_Mode_TypeDef Mode, ADC_DC_Condition_TypeDef Condition)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_DC_MODE(Mode));
|
||||
assert_param(IS_ADC_DC_CONDITION(Condition));
|
||||
|
||||
MODIFY_REG(ADC->DC[DC_Num].DCTL, ADC_DC_DCTL_CTC_Msk | ADC_DC_DCTL_CTM_Msk,
|
||||
((Mode << ADC_DC_DCTL_CTM_Pos) |
|
||||
(Condition << ADC_DC_DCTL_CTC_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения нижней границы цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Val Значение. Диапазон 0-0xFFF.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_SetThresholdLow(ADC_DC_Num_TypeDef DC_Num, uint32_t Val)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_DC_THRESHOLD(Val));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCMP_bit.CMPL, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения нижней границы цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Val Значение. Диапазон 0-0xFFF.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_DC_GetThresholdLow(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return READ_REG(ADC->DC[DC_Num].DCMP_bit.CMPL);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения верхней границы цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Val Значение. Диапазон 0-0xFFF.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_SetThresholdHigh(ADC_DC_Num_TypeDef DC_Num, uint32_t Val)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_DC_THRESHOLD(Val));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCMP_bit.CMPH, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения верхней границы цифрового компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Val Значение. Диапазон 0-0xFFF.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_DC_GetThresholdHigh(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return READ_REG(ADC->DC[DC_Num].DCMP_bit.CMPH);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса события сравнения компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_DC_CmpEventStatus(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->DCTRIG, 1 << ((uint32_t)DC_Num + ADC_DCTRIG_DCEV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса события сравнения компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_CmpEventStatusClear(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
WRITE_REG(ADC->DCTRIG, 1 << ((uint32_t)DC_Num + ADC_DCTRIG_DCEV0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса выходного триггера компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_DC_TrigStatus(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->DCTRIG, 1 << ((uint32_t)DC_Num + ADC_DCTRIG_TOS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс выходного триггера компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_TrigStatusClear(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
WRITE_REG(ADC->DCTRIG, 1 << ((uint32_t)DC_Num + ADC_DCTRIG_TOS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение последнего значения, использованного для сравнения
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Val Значение. Диапазон 0-0xFFF.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_DC_GetLastData(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return READ_REG(ADC->DC[DC_Num].DDATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Functions_Int Конфигурация прерываний
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Functions_Int_DC Цифровые компараторы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение генерации прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_ITCmd(ADC_DC_Num_TypeDef DC_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ADC->DC[DC_Num].DCTL_bit.CIE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка условий и режима работы для генерации прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param Mode Выбор режима
|
||||
* @param Condition Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_ITConfig(ADC_DC_Num_TypeDef DC_Num, ADC_DC_Mode_TypeDef Mode, ADC_DC_Condition_TypeDef Condition)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_ADC_DC_MODE(Mode));
|
||||
assert_param(IS_ADC_DC_CONDITION(Condition));
|
||||
|
||||
MODIFY_REG(ADC->DC[DC_Num].DCTL, ADC_DC_DCTL_CIC_Msk | ADC_DC_DCTL_CIM_Msk,
|
||||
((Mode << ADC_DC_DCTL_CIM_Pos) |
|
||||
(Condition << ADC_DC_DCTL_CIC_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Маскирование прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_ITMaskCmd(ADC_DC_Num_TypeDef DC_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ADC->IM, 1 << ((uint32_t)DC_Num + ADC_IM_DCIM0_Pos), State << ((uint32_t)DC_Num + ADC_IM_DCIM0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос немаскированного состояния прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Status Состояние
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_DC_ITRawStatus(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->RIS, 1 << ((uint32_t)DC_Num + ADC_RIS_DCRIS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос маскированного состояния прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval Status Состояние
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_DC_ITMaskedStatus(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->MIS, 1 << ((uint32_t)DC_Num + ADC_MIS_DCMIS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага прерывания компаратора
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_DC_ITStatusClear(ADC_DC_Num_TypeDef DC_Num)
|
||||
{
|
||||
assert_param(IS_ADC_DC_NUM(DC_Num));
|
||||
|
||||
WRITE_REG(ADC->IC, 1 << ((uint32_t)DC_Num + ADC_IC_DCIC0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Exported_Functions_Int_SEQ Секвенсоры
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Маскирование прерывания секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ITCmd(ADC_SEQ_Num_TypeDef SEQ_Num, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ADC->IM, 1 << ((uint32_t)SEQ_Num + ADC_IM_SEQIM0_Pos), State << ((uint32_t)SEQ_Num + ADC_IM_SEQIM0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка генерации прерывания секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param ITCount Количество запросов модуля АЦП для генерации прерывания.
|
||||
* 0 - по каждому запросу, 0xFF - каждые 256 запросов.
|
||||
* @param ITCountNoRst Активация режима, где счетчик прерывания не будет сбрасываться по запуску секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ITConfig(ADC_SEQ_Num_TypeDef SEQ_Num, uint32_t ITCount, FunctionalState ITCountNoRst)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
assert_param(IS_ADC_SEQ_IT_COUNT_VAL(ITCount));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ITCountNoRst));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SCCTL_bit.ICNT, ITCount);
|
||||
MODIFY_REG(ADC->CICNT, 1 << ((uint32_t)SEQ_Num + ADC_CICNT_ICNT0_Pos), ITCountNoRst << ((uint32_t)SEQ_Num + ADC_CICNT_ICNT0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего состояния счетчика запросов, используемого для генерации прерываний
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Val Значение. Диапазон 0-0xFF.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ADC_SEQ_GetITCountCurrent(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return READ_REG(ADC->SEQ[SEQ_Num].SCVAL_bit.ICNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс счетчика запросов, используемого для генерации прерываний
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ITCountRst(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
WRITE_REG(ADC->SEQ[SEQ_Num].SCVAL_bit.ICLR, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос немаскированного состояния прерывания секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Состояние
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_ITRawStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->RIS, 1 << ((uint32_t)SEQ_Num + ADC_RIS_SEQRIS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос маскированного состояния прерывания секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval Status Состояние
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ADC_SEQ_ITMaskedStatus(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
return (FlagStatus)READ_BIT(ADC->MIS, 1 << ((uint32_t)SEQ_Num + ADC_MIS_SEQMIS0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага прерывания секвенсора
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ADC_SEQ_ITStatusClear(ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
assert_param(IS_ADC_SEQ_NUM(SEQ_Num));
|
||||
|
||||
WRITE_REG(ADC->IC, 1 << ((uint32_t)SEQ_Num + ADC_IC_SEQIC0_Pos));
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_ADC_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
57
MDK-ARM/platform/plib035/inc/plib035_assert.h
Normal file
57
MDK-ARM/platform/plib035/inc/plib035_assert.h
Normal file
@@ -0,0 +1,57 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_assert.h
|
||||
*
|
||||
* @brief Файл управления assert'ами
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_ASSERT_H
|
||||
#define __PLIB035_ASSERT_H
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
/* Exported types ------------------------------------------------------------*/
|
||||
/* Exported constants --------------------------------------------------------*/
|
||||
/* Раскомментируйте строку ниже для включения макроса "assert_param" в коде библиотеки */
|
||||
/* #define USE_FULL_ASSERT 1 */
|
||||
|
||||
/* Exported macro ------------------------------------------------------------*/
|
||||
#ifdef USE_FULL_ASSERT
|
||||
|
||||
/**
|
||||
* @brief Данный макрос используется для проверки параметров, передаваемых функции.
|
||||
* @param expr Если равен FALSE, то вызывается функция assert_failed, которая
|
||||
* показывает имя файла и номер строки, где произошел вызов. Если равен TRUE,
|
||||
* то возвращаемое значение отсутсвует.
|
||||
* @retval Нет
|
||||
*/
|
||||
#define assert_param(expr) ((expr) ? (void)0 : assert_failed((uint8_t*)__FILE__, __LINE__))
|
||||
|
||||
/* Exported functions ------------------------------------------------------- */
|
||||
void assert_failed(uint8_t* file, uint32_t line);
|
||||
#else
|
||||
#define assert_param(expr) ((void)0)
|
||||
#endif /* USE_FULL_ASSERT */
|
||||
|
||||
#endif /* __PLIB035_ASSERT_H */
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
86
MDK-ARM/platform/plib035/inc/plib035_can.h
Normal file
86
MDK-ARM/platform/plib035/inc/plib035_can.h
Normal file
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_can.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* CAN, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_CAN_H
|
||||
#define __PLIB035_CAN_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup CAN
|
||||
* @brief Драйвер для работы с CAN
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_CAN_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
49
MDK-ARM/platform/plib035/inc/plib035_conf.h
Normal file
49
MDK-ARM/platform/plib035/inc/plib035_conf.h
Normal file
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_conf.h
|
||||
*
|
||||
* @brief Файл конфигурации библиотеки
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __PLIB035_CONF_H
|
||||
#define __PLIB035_CONF_H
|
||||
|
||||
/* Раскомментируйте/закоментируйте, чтобы включить/отключить заголовочный файл периферии */
|
||||
#include "plib035_adc.h"
|
||||
#include "plib035_can.h"
|
||||
#include "plib035_dma.h"
|
||||
#include "plib035_ecap.h"
|
||||
#include "plib035_gpio.h"
|
||||
#include "plib035_i2c.h"
|
||||
#include "plib035_mflash.h"
|
||||
#include "plib035_pmu.h"
|
||||
#include "plib035_pwm.h"
|
||||
#include "plib035_qep.h"
|
||||
#include "plib035_rcu.h"
|
||||
#include "plib035_spi.h"
|
||||
#include "plib035_tmr.h"
|
||||
#include "plib035_uart.h"
|
||||
#include "plib035_wdt.h"
|
||||
|
||||
#endif /* __PLIB035_CONF_H */
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
631
MDK-ARM/platform/plib035/inc/plib035_dma.h
Normal file
631
MDK-ARM/platform/plib035/inc/plib035_dma.h
Normal file
@@ -0,0 +1,631 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_dma.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* DMA, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_DMA_H
|
||||
#define __PLIB035_DMA_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA
|
||||
* @brief Драйвер для работы с DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_ChannelMux_Define Мультиплексируемые каналы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define DMA_ChannelMux_8 SIU_DMAMUX_SRCSEL8_Msk /*!< Выбор мультиплексора канала DMA 8 */
|
||||
#define DMA_ChannelMux_9 SIU_DMAMUX_SRCSEL9_Msk /*!< Выбор мультиплексора канала DMA 9 */
|
||||
#define DMA_ChannelMux_10 SIU_DMAMUX_SRCSEL10_Msk /*!< Выбор мультиплексора канала DMA 10 */
|
||||
#define DMA_ChannelMux_11 SIU_DMAMUX_SRCSEL11_Msk /*!< Выбор мультиплексора канала DMA 11 */
|
||||
#define DMA_ChannelMux_12 SIU_DMAMUX_SRCSEL12_Msk /*!< Выбор мультиплексора канала DMA 12 */
|
||||
#define DMA_ChannelMux_13 SIU_DMAMUX_SRCSEL13_Msk /*!< Выбор мультиплексора канала DMA 13 */
|
||||
#define DMA_ChannelMux_14 SIU_DMAMUX_SRCSEL14_Msk /*!< Выбор мультиплексора канала DMA 14 */
|
||||
#define DMA_ChannelMux_15 SIU_DMAMUX_SRCSEL15_Msk /*!< Выбор мультиплексора канала DMA 15 */
|
||||
#define DMA_ChannelMux_All (DMA_ChannelMux_8 | \
|
||||
DMA_ChannelMux_9 | \
|
||||
DMA_ChannelMux_10 | \
|
||||
DMA_ChannelMux_11 | \
|
||||
DMA_ChannelMux_12 | \
|
||||
DMA_ChannelMux_13 | \
|
||||
DMA_ChannelMux_14 | \
|
||||
DMA_ChannelMux_15) /*!< Выбор всех мультиплексоров каналов DMA */
|
||||
|
||||
#define IS_DMA_CHANNEL_MUX_NUM(VALUE) (((VALUE) != 0) && (((VALUE) & (~DMA_ChannelMux_All)) == 0))
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_ChannelMux_Sel_Define Выбор источников мультиплексируемых каналов
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define DMA_ChannelMux_8_QEP (SIU_DMAMUX_SRCSEL8_QEP << SIU_DMAMUX_SRCSEL8_Pos) /*!< Выбор QEP в качестве источника запросов канала DMA 8 */
|
||||
#define DMA_ChannelMux_8_GPIOA (SIU_DMAMUX_SRCSEL8_GPIOA << SIU_DMAMUX_SRCSEL8_Pos) /*!< Выбор GPIOA в качестве источника запросов канала DMA 8 */
|
||||
#define DMA_ChannelMux_9_TMR0 (SIU_DMAMUX_SRCSEL9_TMR0 << SIU_DMAMUX_SRCSEL9_Pos) /*!< Выбор TMR0 в качестве источника запросов канала DMA 9 */
|
||||
#define DMA_ChannelMux_9_GPIOB (SIU_DMAMUX_SRCSEL9_GPIOB << SIU_DMAMUX_SRCSEL9_Pos) /*!< Выбор GPIOB в качестве источника запросов канала DMA 9 */
|
||||
#define DMA_ChannelMux_10_TMR1 (SIU_DMAMUX_SRCSEL10_TMR1 << SIU_DMAMUX_SRCSEL10_Pos) /*!< Выбор TMR1 в качестве источника запросов канала DMA 10 */
|
||||
#define DMA_ChannelMux_10_PWM2B (SIU_DMAMUX_SRCSEL10_PWM0B << SIU_DMAMUX_SRCSEL10_Pos) /*!< Выбор PWM2 B в качестве источника запросов канала DMA 10 */
|
||||
#define DMA_ChannelMux_11_TMR2 (SIU_DMAMUX_SRCSEL11_TMR2 << SIU_DMAMUX_SRCSEL11_Pos) /*!< Выбор TMR2 в качестве источника запросов канала DMA 11 */
|
||||
#define DMA_ChannelMux_11_PWM1B (SIU_DMAMUX_SRCSEL11_PWM1B << SIU_DMAMUX_SRCSEL11_Pos) /*!< Выбор PWM1 B в качестве источника запросов канала DMA 11 */
|
||||
#define DMA_ChannelMux_12_TMR3 (SIU_DMAMUX_SRCSEL12_TMR3 << SIU_DMAMUX_SRCSEL12_Pos) /*!< Выбор TMR3 в качестве источника запросов канала DMA 12 */
|
||||
#define DMA_ChannelMux_12_PWM0B (SIU_DMAMUX_SRCSEL12_PWM2B << SIU_DMAMUX_SRCSEL12_Pos) /*!< Выбор PWM0 B в качестве источника запросов канала DMA 12 */
|
||||
#define DMA_ChannelMux_13_PWM0A (SIU_DMAMUX_SRCSEL13_PWM0A << SIU_DMAMUX_SRCSEL13_Pos) /*!< Выбор PWM0 A в качестве источника запросов канала DMA 13 */
|
||||
#define DMA_ChannelMux_14_PWM1A (SIU_DMAMUX_SRCSEL14_PWM1A << SIU_DMAMUX_SRCSEL14_Pos) /*!< Выбор PWM1 A в качестве источника запросов канала DMA 14 */
|
||||
#define DMA_ChannelMux_15_PWM2A (SIU_DMAMUX_SRCSEL15_PWM2A << SIU_DMAMUX_SRCSEL15_Pos) /*!< Выбор PWM2 A в качестве источника запросов канала DMA 15 */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Channel_Define Маски каналов DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Channel_Num_Define Маски каналов по номеру
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define DMA_Channel_0 0x00000001UL /*!< Канал DMA 0 */
|
||||
#define DMA_Channel_1 0x00000002UL /*!< Канал DMA 1 */
|
||||
#define DMA_Channel_2 0x00000004UL /*!< Канал DMA 2 */
|
||||
#define DMA_Channel_3 0x00000008UL /*!< Канал DMA 3 */
|
||||
#define DMA_Channel_4 0x00000010UL /*!< Канал DMA 4 */
|
||||
#define DMA_Channel_5 0x00000020UL /*!< Канал DMA 5 */
|
||||
#define DMA_Channel_6 0x00000040UL /*!< Канал DMA 6 */
|
||||
#define DMA_Channel_7 0x00000080UL /*!< Канал DMA 7 */
|
||||
#define DMA_Channel_8 0x00000100UL /*!< Канал DMA 8 */
|
||||
#define DMA_Channel_9 0x00000200UL /*!< Канал DMA 9 */
|
||||
#define DMA_Channel_10 0x00000400UL /*!< Канал DMA 10 */
|
||||
#define DMA_Channel_11 0x00000800UL /*!< Канал DMA 11 */
|
||||
#define DMA_Channel_12 0x00001000UL /*!< Канал DMA 12 */
|
||||
#define DMA_Channel_13 0x00002000UL /*!< Канал DMA 13 */
|
||||
#define DMA_Channel_14 0x00004000UL /*!< Канал DMA 14 */
|
||||
#define DMA_Channel_15 0x00008000UL /*!< Канал DMA 15 */
|
||||
#define DMA_Channel_16 0x00010000UL /*!< Канал DMA 16 */
|
||||
#define DMA_Channel_All 0x0000FFFFUL /*!< Все каналы DMA */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Channel_Periph_Define Маски каналов по имени
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define DMA_Channel_UART0_TX DMA_Channel_0 /*!< Канал DMA по передаче от UART0 */
|
||||
#define DMA_Channel_UART1_TX DMA_Channel_1 /*!< Канал DMA по передаче от UART1 */
|
||||
#define DMA_Channel_UART0_RX DMA_Channel_2 /*!< Канал DMA по приему от UART0 */
|
||||
#define DMA_Channel_UART1_RX DMA_Channel_3 /*!< Канал DMA по приему от UART1 */
|
||||
#define DMA_Channel_ADC_SEQ0 DMA_Channel_4 /*!< Канал DMA секвенсора 0 АЦП */
|
||||
#define DMA_Channel_ADC_SEQ1 DMA_Channel_5 /*!< Канал DMA секвенсора 1 АЦП */
|
||||
#define DMA_Channel_SPI_TX DMA_Channel_6 /*!< Канал DMA по передаче от SPI */
|
||||
#define DMA_Channel_SPI_RX DMA_Channel_7 /*!< Канал DMA по приему от SPI */
|
||||
#define DMA_Channel_PWM0_A DMA_Channel_13 /*!< Канал PWM0 A */
|
||||
#define DMA_Channel_PWM1_A DMA_Channel_14 /*!< Канал PWM1 A */
|
||||
#define DMA_Channel_PWM2_A DMA_Channel_15 /*!< Канал PWM2 A */
|
||||
#define DMA_Channel_PWM2_B DMA_Channel_12 /*!< Канал PWM2 B */
|
||||
#define DMA_Channel_PWM1_B DMA_Channel_11 /*!< Канал PWM1 B */
|
||||
#define DMA_Channel_PWM0_B DMA_Channel_10 /*!< Канал PWM0 B */
|
||||
#define DMA_Channel_TMR0 DMA_Channel_9 /*!< Канал TMR0 */
|
||||
#define DMA_Channel_TMR1 DMA_Channel_10 /*!< Канал TMR1 */
|
||||
#define DMA_Channel_TMR2 DMA_Channel_11 /*!< Канал TMR2 */
|
||||
#define DMA_Channel_TMR3 DMA_Channel_12 /*!< Канал TMR3 */
|
||||
#define DMA_Channel_QEP DMA_Channel_8 /*!< Канал QEP */
|
||||
#define DMA_Channel_GPIOA DMA_Channel_8 /*!< Канал GPIOA */
|
||||
#define DMA_Channel_GPIOB DMA_Channel_9 /*!< Канал GPIOB */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#define IS_DMA_CHANNEL(VALUE) (((VALUE) != 0) && (((VALUE)&0xFFFF0000) == 0))
|
||||
|
||||
#define IS_GET_DMA_CHANNEL(VALUE) (((VALUE) == (DMA_Channel_0)) || \
|
||||
((VALUE) == (DMA_Channel_1)) || \
|
||||
((VALUE) == (DMA_Channel_2)) || \
|
||||
((VALUE) == (DMA_Channel_3)) || \
|
||||
((VALUE) == (DMA_Channel_4)) || \
|
||||
((VALUE) == (DMA_Channel_5)) || \
|
||||
((VALUE) == (DMA_Channel_6)) || \
|
||||
((VALUE) == (DMA_Channel_7)) || \
|
||||
((VALUE) == (DMA_Channel_8)) || \
|
||||
((VALUE) == (DMA_Channel_9)) || \
|
||||
((VALUE) == (DMA_Channel_10)) || \
|
||||
((VALUE) == (DMA_Channel_11)) || \
|
||||
((VALUE) == (DMA_Channel_12)) || \
|
||||
((VALUE) == (DMA_Channel_13)) || \
|
||||
((VALUE) == (DMA_Channel_14)) || \
|
||||
((VALUE) == (DMA_Channel_15)))
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы DMA
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
DMA_Mode_Disable = DMA_CHANNEL_CFG_CYCLE_CTRL_Stop, /*!< Неактивное состояние */
|
||||
DMA_Mode_Basic = DMA_CHANNEL_CFG_CYCLE_CTRL_Basic, /*!< Основной режим передачи */
|
||||
DMA_Mode_AutoReq = DMA_CHANNEL_CFG_CYCLE_CTRL_AutoReq, /*!< Режим передачи с авто-запросом */
|
||||
DMA_Mode_PingPong = DMA_CHANNEL_CFG_CYCLE_CTRL_PingPong, /*!< Режим передачи "пинг-понг" */
|
||||
DMA_Mode_PrmMemScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_MemScatGathPrim, /*!< Работа с памятью в режиме "разборка-сборка" с использованием первичной управляющей структуры */
|
||||
DMA_Mode_AltMemScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_MemScatGathAlt, /*!< Работа с памятью в режиме "разборка-сборка" с использованием альтернативной управляющей структуры */
|
||||
DMA_Mode_PrmPeriphScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_PeriphScatGathPrim, /*!< Работа с периферией в режиме "разборка-сборка" с использованием первичной управляющей структуры */
|
||||
DMA_Mode_AltPeriphScatGath = DMA_CHANNEL_CFG_CYCLE_CTRL_PeriphScatGathAlt /*!< Работа с периферией в режиме "разборка-сборка" с использованием альтернативной управляющей структуры */
|
||||
} DMA_Mode_TypeDef;
|
||||
#define IS_DMA_MODE(VALUE) (((VALUE) == DMA_Mode_Disable) || \
|
||||
((VALUE) == DMA_Mode_Basic) || \
|
||||
((VALUE) == DMA_Mode_AutoReq) || \
|
||||
((VALUE) == DMA_Mode_PingPong) || \
|
||||
((VALUE) == DMA_Mode_PrmMemScatGath) || \
|
||||
((VALUE) == DMA_Mode_AltMemScatGath) || \
|
||||
((VALUE) == DMA_Mode_PrmPeriphScatGath) || \
|
||||
((VALUE) == DMA_Mode_AltPeriphScatGath))
|
||||
|
||||
/**
|
||||
* @brief Выбор количества передач до выполнения переарбитрации
|
||||
*/
|
||||
typedef enum {
|
||||
DMA_ArbitrationRate_1, /*!< Переарбитрация каждую передачу DMA */
|
||||
DMA_ArbitrationRate_2, /*!< Переарбитрация каждые 2 передачи DMA */
|
||||
DMA_ArbitrationRate_4, /*!< Переарбитрация каждые 4 передачи DMA */
|
||||
DMA_ArbitrationRate_8, /*!< Переарбитрация каждые 8 передач DMA */
|
||||
DMA_ArbitrationRate_16, /*!< Переарбитрация каждые 16 передач DMA */
|
||||
DMA_ArbitrationRate_32, /*!< Переарбитрация каждые 32 передачи DMA */
|
||||
DMA_ArbitrationRate_64, /*!< Переарбитрация каждые 64 передачи DMA */
|
||||
DMA_ArbitrationRate_128, /*!< Переарбитрация каждые 128 передач DMA */
|
||||
DMA_ArbitrationRate_256, /*!< Переарбитрация каждые 256 передач DMA */
|
||||
DMA_ArbitrationRate_512, /*!< Переарбитрация каждые 512 передач DMA */
|
||||
DMA_ArbitrationRate_1024 /*!< Переарбитрация каждые 1024 передачи DMA */
|
||||
} DMA_ArbitrationRate_TypeDef;
|
||||
#define IS_DMA_ARBITRATION_RATE(VALUE) (((VALUE) == DMA_ArbitrationRate_1) || \
|
||||
((VALUE) == DMA_ArbitrationRate_2) || \
|
||||
((VALUE) == DMA_ArbitrationRate_4) || \
|
||||
((VALUE) == DMA_ArbitrationRate_8) || \
|
||||
((VALUE) == DMA_ArbitrationRate_16) || \
|
||||
((VALUE) == DMA_ArbitrationRate_32) || \
|
||||
((VALUE) == DMA_ArbitrationRate_64) || \
|
||||
((VALUE) == DMA_ArbitrationRate_128) || \
|
||||
((VALUE) == DMA_ArbitrationRate_256) || \
|
||||
((VALUE) == DMA_ArbitrationRate_512) || \
|
||||
((VALUE) == DMA_ArbitrationRate_1024))
|
||||
|
||||
/**
|
||||
* @brief Разрядность данных источника или приемника
|
||||
*/
|
||||
typedef enum {
|
||||
DMA_DataSize_8 = DMA_CHANNEL_CFG_SRC_SIZE_Byte, /*!< Разрядность данных 8 бит */
|
||||
DMA_DataSize_16 = DMA_CHANNEL_CFG_SRC_SIZE_Halfword, /*!< Разрядность данных 16 бит */
|
||||
DMA_DataSize_32 = DMA_CHANNEL_CFG_SRC_SIZE_Word /*!< Разрядность данных 32 бит */
|
||||
} DMA_DataSize_TypeDef;
|
||||
#define IS_DMA_DATA_SIZE(VALUE) (((VALUE) == DMA_DataSize_8) || \
|
||||
((VALUE) == DMA_DataSize_16) || \
|
||||
((VALUE) == DMA_DataSize_32))
|
||||
|
||||
/**
|
||||
* @brief Шаг инкремента адреса источника при чтении или приемника при записи
|
||||
*/
|
||||
typedef enum {
|
||||
DMA_DataInc_8 = DMA_CHANNEL_CFG_SRC_INC_Byte, /*!< Инкремент данных 8 бит */
|
||||
DMA_DataInc_16 = DMA_CHANNEL_CFG_SRC_INC_Halfword, /*!< Инкремент данных 16 бит */
|
||||
DMA_DataInc_32 = DMA_CHANNEL_CFG_SRC_INC_Word, /*!< Инкремент данных 32 бит */
|
||||
DMA_DataInc_Disable = DMA_CHANNEL_CFG_SRC_INC_None /*!< Инкремент отсутствует */
|
||||
} DMA_DataInc_TypeDef;
|
||||
#define IS_DMA_DATA_INC(VALUE) (((VALUE) == DMA_DataInc_8) || \
|
||||
((VALUE) == DMA_DataInc_16) || \
|
||||
((VALUE) == DMA_DataInc_32) || \
|
||||
((VALUE) == DMA_DataInc_Disable))
|
||||
|
||||
/**
|
||||
* @brief Возможные состояния конечного автомата управления контроллером DMA
|
||||
*/
|
||||
typedef enum {
|
||||
DMA_State_Free = DMA_STATUS_STATE_Free, /*!< В покое */
|
||||
DMA_State_ReadConfigData = DMA_STATUS_STATE_ReadConfigData, /*!< Чтение управляющих данных канала */
|
||||
DMA_State_ReadSrcDataEndPtr = DMA_STATUS_STATE_ReadSrcDataEndPtr, /*!< Чтение указателя конца данных источника */
|
||||
DMA_State_ReadDstDataEndPtr = DMA_STATUS_STATE_ReadDstDataEndPtr, /*!< Чтение указателя конца данных приемника */
|
||||
DMA_State_ReadSrcData = DMA_STATUS_STATE_ReadSrcData, /*!< Чтение данных источника */
|
||||
DMA_State_WriteDstData = DMA_STATUS_STATE_WrireDstData, /*!< Запись данных в приемник */
|
||||
DMA_State_WaitReq = DMA_STATUS_STATE_WaitReq, /*!< Ожидание запроса на выполнение прямого доступа */
|
||||
DMA_State_WriteConfigData = DMA_STATUS_STATE_WriteConfigData, /*!< Запись управляющих данных канала */
|
||||
DMA_State_Pause = DMA_STATUS_STATE_Pause, /*!< Приостановлен */
|
||||
DMA_State_Done = DMA_STATUS_STATE_Done, /*!< Выполнен */
|
||||
DMA_State_PeriphScatGath = DMA_STATUS_STATE_PeriphScatGath /*!< Работа с периферией в режиме "разборка-сборка" */
|
||||
} DMA_State_TypeDef;
|
||||
#define IS_DMA_STATE(VALUE) (((VALUE) == DMA_State_Free) || \
|
||||
((VALUE) == DMA_State_ReadConfigData) || \
|
||||
((VALUE) == DMA_State_ReadSrcDataEndPtr) || \
|
||||
((VALUE) == DMA_State_ReadDstDataEndPtr) || \
|
||||
((VALUE) == DMA_State_ReadSrcData) || \
|
||||
((VALUE) == DMA_State_WriteDstData) || \
|
||||
((VALUE) == DMA_State_WaitReq) || \
|
||||
((VALUE) == DMA_State_Pause) || \
|
||||
((VALUE) == DMA_State_Done) || \
|
||||
((VALUE) == DMA_State_PeriphScatGath))
|
||||
|
||||
/**
|
||||
* @brief Защита шины при чтении из источника или записи в приемник через DMA
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState Priveleged; /*!< Управление привелегированным доступом */
|
||||
FunctionalState Bufferable; /*!< Управление буфферизацией доступа */
|
||||
FunctionalState Cacheable; /*!< Управление кэшированием доступа */
|
||||
} DMA_Protect_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации канала DMA
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
void* SrcDataEndPtr; /*!< Указатель конца данных источника */
|
||||
void* DstDataEndPtr; /*!< Указатель конца данных приемника */
|
||||
DMA_Mode_TypeDef Mode; /*!< Выбор режима работы DMA. */
|
||||
FunctionalState NextUseburst; /*!< Контроль установки соответсвующего каналу бита в регистре NT_DMA->CHNL_USEBURST_SET */
|
||||
uint32_t TransfersTotal; /*!< Общее количество передач DMA.
|
||||
Параметр может принимать любое значение из диапазона 1-1024 */
|
||||
DMA_ArbitrationRate_TypeDef ArbitrationRate; /*!< Выбор количества передач до выполнения переарбитрации */
|
||||
DMA_Protect_TypeDef SrcProtect; /*!< Защита шины при чтении из источника через DMA */
|
||||
DMA_Protect_TypeDef DstProtect; /*!< Защита шины при записи в приемник через DMA */
|
||||
DMA_DataSize_TypeDef SrcDataSize; /*!< Разрядность данных источника */
|
||||
DMA_DataSize_TypeDef DstDataSize; /*!< Разрядность данных приемника */
|
||||
DMA_DataInc_TypeDef SrcDataInc; /*!< Шаг инкремента адреса источника при чтении */
|
||||
DMA_DataInc_TypeDef DstDataInc; /*!< Шаг инкремента адреса приемника при записи */
|
||||
} DMA_ChannelInit_TypeDef;
|
||||
#define IS_DMA_TRANSFERS_TOTAL(VALUE) (((VALUE) <= 1024) && ((VALUE) >= 1))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации контроллера DMA
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t Channel; /*!< Определяет каналы, которые будут настроены.
|
||||
Параметр может принимать значение любой комбинации масок DMA_Channel_x из @ref DMA_Channel_Define. */
|
||||
DMA_Protect_TypeDef CtrlProtect; /*!< Управление защитой шины при обращении DMA к управляющим данным */
|
||||
FunctionalState UseBurst; /*!< Установка пакетного обмена каналов DMA */
|
||||
FunctionalState ReqMask; /*!< Маскирование (игнорирование) запросов от периферии на обслуживание каналов DMA */
|
||||
FunctionalState AltCtrl; /*!< Установка альтернативной управляющей структуры каналов DMA */
|
||||
FunctionalState HighPriority; /*!< Установка высокого приоритета каналов DMA */
|
||||
FunctionalState ChannelEnable; /*!< Разрешение работы каналов DMA */
|
||||
} DMA_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка запросов периферии для мультиплексируемых каналов 8-15
|
||||
* @param MuxNum Номера каналов. Любое сочетание значений DMA_ChannelMux_N (@ref DMA_ChannelMux_Define)
|
||||
* @param MuxSel Выбор источников. Любое сочетание значений из DMA_ChannelMux_N_x (@ref DMA_ChannelMux_Sel_Define)
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_ChannelMuxConfig(uint32_t MuxNum, uint32_t MuxSel)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL_MUX_NUM(MuxNum));
|
||||
|
||||
MODIFY_REG(SIU->DMAMUX, MuxNum, MuxSel);
|
||||
}
|
||||
|
||||
/** @defgroup DMA_Exported_Functions_Init_Channel Инициализация каналов DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
void DMA_ChannelDeInit(DMA_Channel_TypeDef* ChannelStruct);
|
||||
void DMA_ChannelInit(DMA_Channel_TypeDef* ChannelStruct, DMA_ChannelInit_TypeDef* ChannelInitStruct);
|
||||
void DMA_ChannelStructInit(DMA_ChannelInit_TypeDef* ChannelInitStruct);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Functions_Init Инициализация контроллера DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
void DMA_DeInit(void);
|
||||
void DMA_Init(DMA_Init_TypeDef* InitStruct);
|
||||
void DMA_StructInit(DMA_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Functions_Config Конфигурация контроллера DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Установка базового адреса управляющих каналов
|
||||
* @param BasePtr Значение базового адреса
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_BasePtrConfig(uint32_t BasePtr)
|
||||
{
|
||||
WRITE_REG(DMA->BASEPTR, BasePtr);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Управление защитой шины при обращении контроллера DMA к управляющим данным
|
||||
* @param CtrlProtect Структура, содержащая конфигурацию защиты
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_ProtectConfig(DMA_Protect_TypeDef* CtrlProtect)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Bufferable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Cacheable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(CtrlProtect->Priveleged));
|
||||
|
||||
MODIFY_REG(DMA->CFG, DMA_CFG_CHPROT_Msk, ((CtrlProtect->Priveleged << (DMA_CFG_CHPROT_Pos + 0)) |
|
||||
(CtrlProtect->Bufferable << (DMA_CFG_CHPROT_Pos + 1)) |
|
||||
(CtrlProtect->Cacheable << (DMA_CFG_CHPROT_Pos + 2))));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешения работы контроллера DMA
|
||||
* @attention Прежде чем включать DMA, необходимо проинициализоровать каналы
|
||||
* с помощью @ref DMA_ChannelInit и сконфигурировать контроллер DMA через функцию
|
||||
* инициализации @ref DMA_Init или вручную - @ref DMA_Exported_Functions_Config.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_MasterEnableCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(DMA->CFG_bit.MASTEREN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный запрос на осуществление передач DMA по выбранным каналам
|
||||
* @param Channel Выбор канала.
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_SwRequestCmd(uint32_t Channel)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
|
||||
WRITE_REG(DMA->SWREQ, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка пакетного обмена каналов DMA
|
||||
* @param Channel Выбор канала.
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_UseBurstCmd(uint32_t Channel, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(DMA->USEBURSTSET, Channel);
|
||||
else
|
||||
WRITE_REG(DMA->USEBURSTCLR, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Маскирование каналов DMA
|
||||
* @attention По маскированным каналам игнорируются запросы на передачи
|
||||
* @param Channel Выбор канала
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_ReqMaskCmd(uint32_t Channel, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(DMA->REQMASKSET, Channel);
|
||||
else
|
||||
WRITE_REG(DMA->REQMASKCLR, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Активация каналов DMA
|
||||
* @param Channel Выбор канала
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_ChannelEnableCmd(uint32_t Channel, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(DMA->ENSET, Channel);
|
||||
else
|
||||
WRITE_REG(DMA->ENCLR, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка альтернативной управляющей структуры каналов DMA
|
||||
* @param Channel Выбор канала.
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_AltCtrlCmd(uint32_t Channel, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(DMA->PRIALTSET, Channel);
|
||||
else
|
||||
WRITE_REG(DMA->PRIALTCLR, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка высокого приоритета каналов DMA
|
||||
* @param Channel Выбор канала.
|
||||
* Параметр принимает любую комбинацию масок DMA_Channel_x из @ref DMA_Channel_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_HighPriorityCmd(uint32_t Channel, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_DMA_CHANNEL(Channel));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(DMA->PRIORITYSET, Channel);
|
||||
else
|
||||
WRITE_REG(DMA->PRIORITYCLR, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Exported_Functions_Status Статусная информация
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Доступ к текущему конечного автомата контроллера DMA
|
||||
* @retval State Текущее состояние конечного автомата
|
||||
*/
|
||||
__STATIC_INLINE DMA_State_TypeDef DMA_StateStatus(void)
|
||||
{
|
||||
return (DMA_State_TypeDef)READ_REG(DMA->STATUS_bit.STATE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Состояние контроллера DMA
|
||||
* @retval State Текущее состояние контроллера DMA
|
||||
*/
|
||||
__STATIC_INLINE FunctionalState DMA_MasterEnableStatus(void)
|
||||
{
|
||||
return (FunctionalState)READ_BIT(DMA->STATUS, DMA_STATUS_MASTEREN_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Состояние канала DMA
|
||||
* @param Channel Выбор канала
|
||||
* @retval State Текущее состояние контроллера DMA
|
||||
*/
|
||||
__STATIC_INLINE FunctionalState DMA_ChannelEnableStatus(uint32_t Channel)
|
||||
{
|
||||
assert_param(IS_GET_DMA_CHANNEL(Channel));
|
||||
|
||||
return (FunctionalState)READ_BIT(DMA->ENSET, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Показывает поддерживает ли канал одиночные SREQ запросы
|
||||
* @param Channel Выбор канала
|
||||
* @retval State Одно из значений @ref FunctionalState:
|
||||
* - ENABLE - поддерживаются SREQ (как и блочные BREQ);
|
||||
* - DISABLE - поддерживаются только блочные запросы BREQ.
|
||||
*/
|
||||
__STATIC_INLINE FunctionalState DMA_WaitOnReqStatus(uint32_t Channel)
|
||||
{
|
||||
assert_param(IS_GET_DMA_CHANNEL(Channel));
|
||||
|
||||
return (FunctionalState)READ_BIT(DMA->WAITONREQ, Channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Показывает наличие ошибки на шине
|
||||
* @retval Status Одно из значений @ref OperationStatus:
|
||||
* - OK - ошибок не было;
|
||||
* - ERROR - произошла ошибка.
|
||||
*/
|
||||
__STATIC_INLINE OperationStatus DMA_ErrorStatus(void)
|
||||
{
|
||||
return (OperationStatus)READ_BIT(DMA->ERRCLR, DMA_ERRCLR_VAL_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага ошибки на шине
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void DMA_ClearErrorStatus(void)
|
||||
{
|
||||
WRITE_REG(DMA->ERRCLR, DMA_ERRCLR_VAL_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_DMA_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
910
MDK-ARM/platform/plib035/inc/plib035_ecap.h
Normal file
910
MDK-ARM/platform/plib035/inc/plib035_ecap.h
Normal file
@@ -0,0 +1,910 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_ecap.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* ECAP, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_ECAP_H
|
||||
#define __PLIB035_ECAP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP
|
||||
* @brief Драйвер для работы с ECAP
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_ITStatus_Define Флаги прерываний
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define ECAP_ITStatus_GeneralInt ECAP_ECFLG_INT_Msk /*!< Общее прерывание */
|
||||
#define ECAP_ITStatus_CapEvt0 ECAP_ECFLG_CEVT0_Msk /*!< Событие захвата 0 */
|
||||
#define ECAP_ITStatus_CapEvt1 ECAP_ECFLG_CEVT1_Msk /*!< Событие захвата 1 */
|
||||
#define ECAP_ITStatus_CapEvt2 ECAP_ECFLG_CEVT2_Msk /*!< Событие захвата 2 */
|
||||
#define ECAP_ITStatus_CapEvt3 ECAP_ECFLG_CEVT3_Msk /*!< Событие захвата 3 */
|
||||
#define ECAP_ITStatus_TimerOvf ECAP_ECFLG_CTROVF_Msk /*!< Переполнение счетчика таймера */
|
||||
#define ECAP_ITStatus_TimerEqPeriod ECAP_ECFLG_CTRPRD_Msk /*!< Счетчик таймера равен периоду (в режиме ШИМ) */
|
||||
#define ECAP_ITStatus_TimerEqCompare ECAP_ECFLG_CTRCMP_Msk /*!< Счетчик таймера равен значению сравнения (в режиме ШИМ) */
|
||||
#define ECAP_ITStatus_All (ECAP_ITStatus_GeneralInt | \
|
||||
ECAP_ITStatus_CapEvt0 | \
|
||||
ECAP_ITStatus_CapEvt1 | \
|
||||
ECAP_ITStatus_CapEvt2 | \
|
||||
ECAP_ITStatus_CapEvt3 | \
|
||||
ECAP_ITStatus_TimerOvf | \
|
||||
ECAP_ITStatus_TimerEqPeriod | \
|
||||
ECAP_ITStatus_TimerEqCompare) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_ECAP_IT_STATUS(VALUE) (((VALUE) & ~ECAP_ITStatus_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_ITSource_Define Маски источников прерываний
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define ECAP_ITSource_CapEvt0 ECAP_ECEINT_CEVT0_Msk /*!< Событие захвата 0 */
|
||||
#define ECAP_ITSource_CapEvt1 ECAP_ECEINT_CEVT1_Msk /*!< Событие захвата 1 */
|
||||
#define ECAP_ITSource_CapEvt2 ECAP_ECEINT_CEVT2_Msk /*!< Событие захвата 2 */
|
||||
#define ECAP_ITSource_CapEvt3 ECAP_ECEINT_CEVT3_Msk /*!< Событие захвата 3 */
|
||||
#define ECAP_ITSource_TimerOvf ECAP_ECEINT_CTROVF_Msk /*!< Переполнение счетчика таймера */
|
||||
#define ECAP_ITSource_TimerEqPeriod ECAP_ECEINT_CTRPRD_Msk /*!< Счетчик таймера равен периоду (в режиме ШИМ) */
|
||||
#define ECAP_ITSource_TimerEqCompare ECAP_ECEINT_CTRCMP_Msk /*!< Счетчик таймера равен значению сравнения (в режиме ШИМ) */
|
||||
#define ECAP_ITSource_All (ECAP_ITSource_CapEvt0 | \
|
||||
ECAP_ITSource_CapEvt1 | \
|
||||
ECAP_ITSource_CapEvt2 | \
|
||||
ECAP_ITSource_CapEvt3 | \
|
||||
ECAP_ITSource_TimerOvf | \
|
||||
ECAP_ITSource_TimerEqPeriod | \
|
||||
ECAP_ITSource_TimerEqCompare) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_ECAP_IT_SOURCE(VALUE) (((VALUE) & ~ECAP_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор фронта захвата
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_Capture_Polarity_PosEdge, /*!< Захват по переднему фронту */
|
||||
ECAP_Capture_Polarity_NegEdge /*!< Захват по заднему фронту */
|
||||
} ECAP_Capture_Polarity_TypeDef;
|
||||
#define IS_ECAP_CAPTURE_POLARITY(VALUE) (((VALUE) == ECAP_Capture_Polarity_PosEdge) || \
|
||||
((VALUE) == ECAP_Capture_Polarity_NegEdge))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима остановки таймера при отладке
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_Halt_Stop = ECAP_ECCTL0_FREESOFT_Stop, /*!< Мгновенная остановка таймера при отладке */
|
||||
ECAP_Halt_StopOnZero = ECAP_ECCTL0_FREESOFT_StopAtZero, /*!< Остановка таймера при переполнении или сбросе (событие достижения 0) */
|
||||
ECAP_Halt_Free = ECAP_ECCTL0_FREESOFT_Free /*!< Нормальный режим */
|
||||
} ECAP_Halt_TypeDef;
|
||||
#define IS_ECAP_HALT(VALUE) (((VALUE) == ECAP_Halt_Stop) || \
|
||||
((VALUE) == ECAP_Halt_StopOnZero) || \
|
||||
((VALUE) == ECAP_Halt_Free))
|
||||
|
||||
/**
|
||||
* @brief Выбор источника выходного сигнала синхронизации
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_SyncOut_Bypass = ECAP_ECCTL1_SYNCOSEL_Bypass, /*!< Пропуск синхросигнала со входа на выход */
|
||||
ECAP_SyncOut_TimerEqPeriod = ECAP_ECCTL1_SYNCOSEL_CTREqPrd, /*!< Передача события равенства таймера и значения периода в качестве выходного сигнала синхронизации */
|
||||
ECAP_SyncOut_Disable = ECAP_ECCTL1_SYNCOSEL_Disable /*!< Выходной сигнал синхронизации запрещен */
|
||||
} ECAP_SyncOut_TypeDef;
|
||||
#define IS_ECAP_SYNC_OUT(VALUE) (((VALUE) == ECAP_SyncOut_Bypass) || \
|
||||
((VALUE) == ECAP_SyncOut_TimerEqPeriod) || \
|
||||
((VALUE) == ECAP_SyncOut_Disable))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы захвата
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_Capture_Mode_Cycle, /*!< Цикличный захват */
|
||||
ECAP_Capture_Mode_Single /*!< Однократный захват */
|
||||
} ECAP_Capture_Mode_TypeDef;
|
||||
#define IS_ECAP_CAPTURE_MODE(VALUE) (((VALUE) == ECAP_Capture_Mode_Single) || \
|
||||
((VALUE) == ECAP_Capture_Mode_Cycle))
|
||||
|
||||
/**
|
||||
* @brief Выбор активного уровня в режиме ШИМ
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_PWM_Polarity_Pos, /*!< Высокий уровень является активным */
|
||||
ECAP_PWM_Polarity_Neg /*!< Низкий уровень является активным */
|
||||
} ECAP_PWM_Polarity_TypeDef;
|
||||
#define IS_ECAP_PWM_POLARITY(VALUE) (((VALUE) == ECAP_PWM_Polarity_Pos) || \
|
||||
((VALUE) == ECAP_PWM_Polarity_Neg))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы блока захвата
|
||||
*/
|
||||
typedef enum {
|
||||
ECAP_Mode_Capture, /*!< Режим захвата */
|
||||
ECAP_Mode_PWM /*!< Режим ШИМ */
|
||||
} ECAP_Mode_TypeDef;
|
||||
#define IS_ECAP_MODE(VALUE) (((VALUE) == ECAP_Mode_Capture) || \
|
||||
((VALUE) == ECAP_Mode_PWM))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации блока захвата в целом
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ECAP_Halt_TypeDef Halt; /*!< Выбор режима остановки таймера при отладке */
|
||||
FunctionalState SyncEn; /*!< Определеяет возможность синхронизации */
|
||||
ECAP_SyncOut_TypeDef SyncOut; /*!< Выбор источника выходного сигнала синхронизации */
|
||||
ECAP_Mode_TypeDef Mode; /*!< Выбор режима работы блока захвата */
|
||||
} ECAP_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации режима захвата
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t Prescale; /*!< Предварительный делитель событий.
|
||||
Параметр может принимать любое значение из диапазона 0-63. 0 - делитель выключен. */
|
||||
ECAP_Capture_Mode_TypeDef Mode; /*!< Определеяет режим работы захвата */
|
||||
uint32_t StopVal; /*!< Значение счетчика событий для остановки одиночного режима захвата.
|
||||
Параметр может принимать любое значение из диапазона 0-3. */
|
||||
FunctionalState RstEvt0; /*!< Определеяет сброс таймера после события захвата 0 */
|
||||
FunctionalState RstEvt1; /*!< Определеяет сброс таймера после события захвата 1 */
|
||||
FunctionalState RstEvt2; /*!< Определеяет сброс таймера после события захвата 2 */
|
||||
FunctionalState RstEvt3; /*!< Определеяет сброс таймера после события захвата 3 */
|
||||
ECAP_Capture_Polarity_TypeDef PolarityEvt0; /*!< Определеяет фронт события захвата 0 */
|
||||
ECAP_Capture_Polarity_TypeDef PolarityEvt1; /*!< Определеяет фронт события захвата 1 */
|
||||
ECAP_Capture_Polarity_TypeDef PolarityEvt2; /*!< Определеяет фронт события захвата 2 */
|
||||
ECAP_Capture_Polarity_TypeDef PolarityEvt3; /*!< Определеяет фронт события захвата 3 */
|
||||
} ECAP_Capture_Init_TypeDef;
|
||||
#define IS_ECAP_CAPTURE_PRESCALE(VALUE) ((VALUE) < 0x40)
|
||||
#define IS_ECAP_CAPTURE_STOP(VALUE) ((VALUE) < 0x4)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации режима ШИМ
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t Period; /*!< Значение периода ШИМ.
|
||||
Параметр может принимать любое значение из диапазона 0x00000000-0xFFFFFFFF. */
|
||||
uint32_t Compare; /*!< Значение сравнения ШИМ.
|
||||
Параметр может принимать любое значение из диапазона 0x00000000-0xFFFFFFFF. */
|
||||
ECAP_PWM_Polarity_TypeDef Polarity; /*!< Выбор полярности ШИМ сигнала */
|
||||
} ECAP_PWM_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup CAP_Config Конфигурация
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ECAP_DeInit(ECAP_TypeDef* ECAPx);
|
||||
void ECAP_Init(ECAP_TypeDef* ECAPx, ECAP_Init_TypeDef* InitStruct);
|
||||
void ECAP_StructInit(ECAP_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы вывода блока захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_RemapCmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (ECAPx == ECAP0)
|
||||
WRITE_REG(SIU->REMAPAF_bit.ECAP0EN, State);
|
||||
else if (ECAPx == ECAP1)
|
||||
WRITE_REG(SIU->REMAPAF_bit.ECAP1EN, State);
|
||||
else /* (ECAPx == ECAP2) */
|
||||
WRITE_REG(SIU->REMAPAF_bit.ECAP2EN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима остановки таймера при отладке
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Halt Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_HaltConfig(ECAP_TypeDef* ECAPx, ECAP_Halt_TypeDef Halt)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_HALT(Halt));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.FREESOFT, Halt);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима работы блока захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_ModeConfig(ECAP_TypeDef* ECAPx, ECAP_Mode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_MODE(Mode));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.CAPAPWM, Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы таймера, выбранного блока захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_TimerCmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.TSCTRSTOP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка текущего значения счетчика напрямую
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param TimerVal Значение таймера
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_SetTimer(ECAP_TypeDef* ECAPx, uint32_t TimerVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->TSCTR, TimerVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка теневого значения таймера для отложенной записи
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param TimerVal Значение таймера
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_SetShadowTimer(ECAP_TypeDef* ECAPx, uint32_t TimerVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CTRPHS, TimerVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения таймера
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение таймера
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_GetTimer(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->TSCTR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение отложенного значения таймера
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение таймера
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_GetShadowTimer(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CTRPHS);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка источника выходного сигнала синхронизации
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param SyncOut Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_SyncOutConfig(ECAP_TypeDef* ECAPx, ECAP_SyncOut_TypeDef SyncOut)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_SYNC_OUT(SyncOut));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.SYNCOSEL, SyncOut);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение синхронизации
|
||||
* @param ECAPx Выбор модуля CAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_SyncCmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.SYNCIEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Проведение программной синхронизации
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_SwSync(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.SWSYNC, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAP_Config_PWM_Mode Режим ШИМ
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ECAP_PWM_Init(ECAP_TypeDef* ECAPx, ECAP_PWM_Init_TypeDef* InitStruct);
|
||||
void ECAP_PWM_StructInit(ECAP_PWM_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Настройка полярности ШИМ сигнала
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_PWM_PolarityConfig(ECAP_TypeDef* ECAPx, ECAP_PWM_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_PWM_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.APWMPOL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода ШИМ
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Значение периода
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_PWM_SetPeriod(ECAP_TypeDef* ECAPx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->PRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения сравнения ШИМ.
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param CompareVal Значение сравнения.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_PWM_SetCompare(ECAP_TypeDef* ECAPx, uint32_t CompareVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CMP, CompareVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода ШИМ для отложенной записи
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Значение периода
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_PWM_SetShadowPeriod(ECAP_TypeDef* ECAPx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->PRDSHDW, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения сравнения ШИМ для отложенной записи
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param CompareVal Значение сравнения
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_PWM_SetShadowCompare(ECAP_TypeDef* ECAPx, uint32_t CompareVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CMPSHDW, CompareVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего периода ШИМ
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение периода
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_PWM_GetPeriod(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->PRD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения сравнения ШИМ
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение сравнения
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_PWM_GetCompare(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CMP);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение отложенного значения периода ШИМ
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение периода
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_PWM_GetShadowPeriod(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->PRDSHDW);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение отложенного значения сравнения ШИМ
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение сравнения
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_PWM_GetShadowCompare(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CMPSHDW);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAP_Config_CAP_Mode Режим захвата
|
||||
* @{
|
||||
*/
|
||||
|
||||
void ECAP_Capture_Init(ECAP_TypeDef* ECAPx, ECAP_Capture_Init_TypeDef* InitStruct);
|
||||
void ECAP_Capture_StructInit(ECAP_Capture_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Настройка режима захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_ModeConfig(ECAP_TypeDef* ECAPx, ECAP_Capture_Mode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_MODE(Mode));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.CONTOST, Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка счетчика событий для остановки одиночного режима захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param StopVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_StopConfig(ECAP_TypeDef* ECAPx, uint32_t StopVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_STOP(StopVal));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.STOPWRAP, StopVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка предварительного делителя событий
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param PrescaleVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_PrescaleConfig(ECAP_TypeDef* ECAPx, uint32_t PrescaleVal)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_PRESCALE(PrescaleVal));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.PRESCALE, PrescaleVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка фронта события захвата 0
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Значение режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_PolarityEvt0Config(ECAP_TypeDef* ECAPx, ECAP_Capture_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CAP0POL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка фронта события захвата 1
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Значение режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_PolarityEvt1Config(ECAP_TypeDef* ECAPx, ECAP_Capture_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CAP1POL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка фронта события захвата 2
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Значение режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_PolarityEvt2Config(ECAP_TypeDef* ECAPx, ECAP_Capture_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CAP2POL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка фронта события захвата 3
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Значение режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_PolarityEvt3Config(ECAP_TypeDef* ECAPx, ECAP_Capture_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_CAPTURE_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CAP3POL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение сброса таймера после события захвата 0
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_RstEvt0Cmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CTRRST0, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение сброса таймера после события захвата 1
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_RstEvt1Cmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CTRRST1, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение сброса таймера после события захвата 2
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_RstEvt2Cmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CTRRST2, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение сброса таймера после события захвата 3
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_RstEvt3Cmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CTRRST3, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение захвата для выбранного блока захвата
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_Cmd(ECAP_TypeDef* ECAPx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(ECAPx->ECCTL1_bit.REARM, State);
|
||||
WRITE_REG(ECAPx->ECCTL0_bit.CAPLDEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения регистра захвата 0
|
||||
* @param ECAPx Выбор таймера, где x лежит в диапазоне 0-2
|
||||
* @param Value Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_SetCap0(ECAP_TypeDef* ECAPx, uint32_t Value)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CAP0, Value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения регистра захвата 1
|
||||
* @param ECAPx Выбор таймера, где x лежит в диапазоне 0-2
|
||||
* @param Value Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_SetCap1(ECAP_TypeDef* ECAPx, uint32_t Value)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CAP1, Value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения регистра захвата 2
|
||||
* @param ECAPx Выбор таймера, где x лежит в диапазоне 0-2
|
||||
* @param Value Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_SetCap2(ECAP_TypeDef* ECAPx, uint32_t Value)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CAP2, Value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения регистра захвата 3
|
||||
* @param ECAPx Выбор таймера, где x лежит в диапазоне 0-2
|
||||
* @param Value Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_Capture_SetCap3(ECAP_TypeDef* ECAPx, uint32_t Value)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->CAP3, Value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения из регистра захвата 0
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_Capture_GetCap0(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CAP0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения из регистра захвата 1
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_Capture_GetCap1(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CAP1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения из регистра захвата 2
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_Capture_GetCap2(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CAP2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения из регистра захвата 3
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ECAP_Capture_GetCap3(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return READ_REG(ECAPx->CAP3);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAP_IT Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации прерываний
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источников прерывания
|
||||
* Параметр принимает любою совокупность значений ECAP_ITSource_x из @ref ECAP_ITSource_define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_ITCmd(ECAP_TypeDef* ECAPx, uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_IT_SOURCE(ITSource));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(ECAPx->ECEINT, ITSource, State ? (uint32_t)ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Принудительный вызов прерывания выбранного блока захвата
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источников прерывания
|
||||
* Параметр принимает любою совокупность значений ECAP_ITSource_x из @ref ECAP_ITSource_define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_ITForceCmd(ECAP_TypeDef* ECAPx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(ECAPx->ECFRC, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса прерывания выбранного блока захвата
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флага прерывания.
|
||||
* Параметр принимает любою совокупность значений ECAP_ITStatus_x из @ref ECAP_ITStatus_define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ECAP_ITStatus(ECAP_TypeDef* ECAPx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_IT_STATUS(ITStatus));
|
||||
|
||||
return (FlagStatus)READ_BIT(ECAPx->ECFLG, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса прерывания выбранного блока захвата
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флага прерывания.
|
||||
* Параметр принимает любою совокупность значений ECAP_ITStatus_x из @ref ECAP_ITStatus_define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_ITStatusClear(ECAP_TypeDef* ECAPx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
assert_param(IS_ECAP_IT_STATUS(ITStatus));
|
||||
|
||||
WRITE_REG(ECAPx->ECCLR, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение активного статуса прерывания выбранного блока захвата
|
||||
* @param ECAPx Выбор ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval Status Статус прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus ECAP_ITPendStatus(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
return (FlagStatus)READ_BIT(ECAPx->PEINT, ECAP_PEINT_PEINT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс активности прерывания выбранного блока захвата.
|
||||
* @param CAPx Выбор CAP, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void ECAP_ITPendStatusClear(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
WRITE_REG(ECAPx->PEINT, ECAP_PEINT_PEINT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_ECAP_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
832
MDK-ARM/platform/plib035/inc/plib035_gpio.h
Normal file
832
MDK-ARM/platform/plib035/inc/plib035_gpio.h
Normal file
@@ -0,0 +1,832 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_gpio.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* GPIO, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_GPIO_H
|
||||
#define __PLIB035_GPIO_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO
|
||||
* @brief Драйвер для работы с GPIO
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Pin_Define Маски пинов
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define GPIO_Pin_0 0x0001UL /*!< Пин 0 выбран */
|
||||
#define GPIO_Pin_1 0x0002UL /*!< Пин 1 выбран */
|
||||
#define GPIO_Pin_2 0x0004UL /*!< Пин 2 выбран */
|
||||
#define GPIO_Pin_3 0x0008UL /*!< Пин 3 выбран */
|
||||
#define GPIO_Pin_4 0x0010UL /*!< Пин 4 выбран */
|
||||
#define GPIO_Pin_5 0x0020UL /*!< Пин 5 выбран */
|
||||
#define GPIO_Pin_6 0x0040UL /*!< Пин 6 выбран */
|
||||
#define GPIO_Pin_7 0x0080UL /*!< Пин 7 выбран */
|
||||
#define GPIO_Pin_8 0x0100UL /*!< Пин 8 выбран */
|
||||
#define GPIO_Pin_9 0x0200UL /*!< Пин 9 выбран */
|
||||
#define GPIO_Pin_10 0x0400UL /*!< Пин 10 выбран */
|
||||
#define GPIO_Pin_11 0x0800UL /*!< Пин 11 выбран */
|
||||
#define GPIO_Pin_12 0x1000UL /*!< Пин 12 выбран */
|
||||
#define GPIO_Pin_13 0x2000UL /*!< Пин 13 выбран */
|
||||
#define GPIO_Pin_14 0x4000UL /*!< Пин 14 выбран */
|
||||
#define GPIO_Pin_15 0x8000UL /*!< Пин 15 выбран */
|
||||
#define GPIO_Pin_0_3 0x000FUL /*!< Пины 0-3 выбраны */
|
||||
#define GPIO_Pin_3_0 GPIO_Pin_0_3 /*!< Пины 3-0 выбраны */
|
||||
#define GPIO_Pin_4_7 0x00F0UL /*!< Пины 4-7 выбраны */
|
||||
#define GPIO_Pin_7_4 GPIO_Pin_4_7 /*!< Пины 7-4 выбраны */
|
||||
#define GPIO_Pin_8_11 0x0F00UL /*!< Пины 8-11 выбраны */
|
||||
#define GPIO_Pin_11_8 GPIO_Pin_8_11 /*!< Пины 11-8 выбраны */
|
||||
#define GPIO_Pin_12_15 0xF000UL /*!< Пины 12-15 выбраны */
|
||||
#define GPIO_Pin_15_12 GPIO_Pin_12_15 /*!< Пины 15-12 выбраны */
|
||||
#define GPIO_Pin_0_7 0x00FFUL /*!< Пины 0-7 выбраны */
|
||||
#define GPIO_Pin_7_0 GPIO_Pin_0_7 /*!< Пины 7-0 выбраны */
|
||||
#define GPIO_Pin_8_15 0xFF00UL /*!< Пины 8-15 выбраны */
|
||||
#define GPIO_Pin_15_8 GPIO_Pin_8_15 /*!< Пины 15-8 выбраны */
|
||||
#define GPIO_Pin_All 0xFFFFUL /*!< Все пины выбраны */
|
||||
|
||||
#define IS_GPIO_PIN(VALUE) (((VALUE) != 0) && (((VALUE)&0xFFFF0000) == 0))
|
||||
|
||||
#define IS_GET_GPIO_PIN(VALUE) (((VALUE) == GPIO_Pin_0) || \
|
||||
((VALUE) == GPIO_Pin_1) || \
|
||||
((VALUE) == GPIO_Pin_2) || \
|
||||
((VALUE) == GPIO_Pin_3) || \
|
||||
((VALUE) == GPIO_Pin_4) || \
|
||||
((VALUE) == GPIO_Pin_5) || \
|
||||
((VALUE) == GPIO_Pin_6) || \
|
||||
((VALUE) == GPIO_Pin_7) || \
|
||||
((VALUE) == GPIO_Pin_8) || \
|
||||
((VALUE) == GPIO_Pin_9) || \
|
||||
((VALUE) == GPIO_Pin_10) || \
|
||||
((VALUE) == GPIO_Pin_11) || \
|
||||
((VALUE) == GPIO_Pin_12) || \
|
||||
((VALUE) == GPIO_Pin_13) || \
|
||||
((VALUE) == GPIO_Pin_14) || \
|
||||
((VALUE) == GPIO_Pin_15))
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы пина
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_Mode_IO, /*!< Пин в режиме ввода-вывода */
|
||||
GPIO_Mode_AltFunc /*!< Пин в режиме альтернативной функции */
|
||||
} GPIO_Mode_TypeDef;
|
||||
#define IS_GPIO_MODE(VALUE) (((VALUE) == GPIO_Mode_IO) || \
|
||||
((VALUE) == GPIO_Mode_AltFunc))
|
||||
|
||||
/**
|
||||
* @brief Выбор события для возникновения прерывания
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_IntType_Level, /*!< Прерывание по уровню */
|
||||
GPIO_IntType_Edge /*!< Прерывание по перепаду */
|
||||
} GPIO_IntType_TypeDef;
|
||||
#define IS_GPIO_INT_TYPE(VALUE) (((VALUE) == GPIO_IntType_Level) || \
|
||||
((VALUE) == GPIO_IntType_Edge))
|
||||
|
||||
/**
|
||||
* @brief Выбор полярности события для возникновения прерывания
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_IntPol_Negative, /*!< Прерывание по низкому уровню или отрицательному фронту */
|
||||
GPIO_IntPol_Positive /*!< Прерывание по высокому уровню или положительному фронту */
|
||||
} GPIO_IntPol_TypeDef;
|
||||
#define IS_GPIO_INT_POL(VALUE) (((VALUE) == GPIO_IntPol_Negative) || \
|
||||
((VALUE) == GPIO_IntPol_Positive))
|
||||
|
||||
/**
|
||||
* @brief Выбор количества фронтов, ипользуемых в генерации прерывания по фронту
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_IntEdge_Polarity, /*!< Прерывание согласно выбранной полярности фронта */
|
||||
GPIO_IntEdge_Any /*!< Прерывание по обоим фронтам */
|
||||
} GPIO_IntEdge_TypeDef;
|
||||
#define IS_GPIO_INT_EDGE(VALUE) (((VALUE) == GPIO_IntEdge_Polarity) || \
|
||||
((VALUE) == GPIO_IntEdge_Any))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы выходных каскадов
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_OutMode_PP = GPIO_OUTMODE_PIN0_PP, /*!< Режим push-pull */
|
||||
GPIO_OutMode_OD = GPIO_OUTMODE_PIN0_OD, /*!< Режим open-drain */
|
||||
GPIO_OutMode_OS = GPIO_OUTMODE_PIN0_OS /*!< Режим open-source */
|
||||
} GPIO_OutMode_TypeDef;
|
||||
#define IS_GPIO_OUT_MODE(VALUE) (((VALUE) == GPIO_OutMode_PP) || \
|
||||
((VALUE) == GPIO_OutMode_OD) || \
|
||||
((VALUE) == GPIO_OutMode_OS))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы входа
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_InMode_Schmitt = GPIO_INMODE_PIN0_Schmitt, /*!< Режим push-pull */
|
||||
GPIO_InMode_CMOS = GPIO_INMODE_PIN0_CMOS, /*!< Режим open-drain */
|
||||
GPIO_InMode_Disable = GPIO_INMODE_PIN0_Disable /*!< Режим open-source */
|
||||
} GPIO_InMode_TypeDef;
|
||||
#define IS_GPIO_IN_MODE(VALUE) (((VALUE) == GPIO_InMode_Schmitt) || \
|
||||
((VALUE) == GPIO_InMode_CMOS) || \
|
||||
((VALUE) == GPIO_InMode_Disable))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы подтяжки
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_PullMode_Disable = GPIO_PULLMODE_PIN0_Disable, /*!< Внутренняя подтяжка выключена */
|
||||
GPIO_PullMode_PU = GPIO_PULLMODE_PIN0_PU, /*!< Внутренняя подтяжка к питанию включена */
|
||||
GPIO_PullMode_PD = GPIO_PULLMODE_PIN0_PD /*!< Внутренняя подтяжка к земле включена */
|
||||
} GPIO_PullMode_TypeDef;
|
||||
#define IS_GPIO_PULL_MODE(VALUE) (((VALUE) == GPIO_PullMode_Disable) || \
|
||||
((VALUE) == GPIO_PullMode_PU) || \
|
||||
((VALUE) == GPIO_PullMode_PD))
|
||||
|
||||
/**
|
||||
* @brief Выбор нагрузочной способности и скорости переключения пина
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_DriveMode_HighFast = GPIO_DRIVEMODE_PIN0_HF, /*!< Высокая нагрузочная способность и высокая скорость переключения */
|
||||
GPIO_DriveMode_HighSlow = GPIO_DRIVEMODE_PIN0_HS, /*!< Высокая нагрузочная способность и низкая скорость переключения */
|
||||
GPIO_DriveMode_LowFast = GPIO_DRIVEMODE_PIN0_LF, /*!< Низкая нагрузочная способность и высокая скорость переключения */
|
||||
GPIO_DriveMode_LowSlow = GPIO_DRIVEMODE_PIN0_LS /*!< Низкая нагрузочная способность и низкая скорость переключения */
|
||||
} GPIO_DriveMode_TypeDef;
|
||||
#define IS_GPIO_DRIVE_MODE(VALUE) (((VALUE) == GPIO_DriveMode_HighFast) || \
|
||||
((VALUE) == GPIO_DriveMode_HighSlow) || \
|
||||
((VALUE) == GPIO_DriveMode_LowFast) || \
|
||||
((VALUE) == GPIO_DriveMode_LowSlow))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы входного фильтра пина
|
||||
*/
|
||||
typedef enum {
|
||||
GPIO_QualMode_3Sample, /*!< Используется 3 отсчета для фильтрации */
|
||||
GPIO_QualMode_6Sample /*!< Используется 6 отсчетов для фильтрации */
|
||||
} GPIO_QualMode_TypeDef;
|
||||
#define IS_GPIO_QUAL_MODE(VALUE) (((VALUE) == GPIO_QualMode_3Sample) || \
|
||||
((VALUE) == GPIO_QualMode_6Sample))
|
||||
|
||||
#define IS_GPIO_QUAL_PERIOD(VALUE) (((VALUE)&0xFFFFFF00) == 0)
|
||||
#define IS_GPIO_MASK(VALUE) (((VALUE)&0xFFFFFF00) == 0)
|
||||
#define IS_GPIO_VAL(VALUE) (((VALUE)&0xFFFF0000) == 0)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации GPIO
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t Pin; /*!< Определяет пины, которые будут настроены.
|
||||
Параметр может принимать любое значение из @ref GPIO_Pin_Define. */
|
||||
FunctionalState Out; /*!< Определяет включение выхода выбранных пинов */
|
||||
FunctionalState AltFunc; /*!< Определяет режим работы периферийной функции пинов */
|
||||
FunctionalState Digital; /*!< Определяет включение цифровой функции порта */
|
||||
GPIO_OutMode_TypeDef OutMode; /*!< Определяет режим работы выходных каскадов выбранных пинов */
|
||||
GPIO_InMode_TypeDef InMode; /*!< Определяет режим работы входов выбранных пинов */
|
||||
GPIO_PullMode_TypeDef PullMode; /*!< Определяет режим работы подтяжки выбранных пинов */
|
||||
GPIO_DriveMode_TypeDef DriveMode; /*!< Определяет нагрузочную способность и скорость переключения выбранных пинов */
|
||||
} GPIO_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Init_Deinit Инициализация и деинициализация
|
||||
* @{
|
||||
*/
|
||||
|
||||
void GPIO_DeInit(GPIO_TypeDef* GPIOx);
|
||||
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_Init_TypeDef* InitStruct);
|
||||
void GPIO_StructInit(GPIO_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Config Конфигурация
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение цифровой работы (вход или выход) выбранных пинов
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_DigitalCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->DENSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->DENCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение выхода выбранных пинов
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_OutCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->OUTENSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->OUTENCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение периферийной функции выбранных пинов
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_AltFuncCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->ALTFUNCSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->ALTFUNCCLR, Pin);
|
||||
}
|
||||
|
||||
void GPIO_OutModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_OutMode_TypeDef OutMode);
|
||||
void GPIO_InModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_InMode_TypeDef InMode);
|
||||
void GPIO_PullModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_PullMode_TypeDef PullMode);
|
||||
void GPIO_DriveModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_DriveMode_TypeDef DriveMode);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Read_Write Чтение и запись
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Read Чтение
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Чтение состояния выбранного пина
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пина
|
||||
* @retval State Состояние Если выбрано несколько пинов, то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE BitState GPIO_ReadBit(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GET_GPIO_PIN(Pin));
|
||||
|
||||
return (BitState)READ_BIT(GPIOx->DATA, (uint32_t)Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение состояния выбранного порта
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @retval Val Состояние
|
||||
*/
|
||||
__STATIC_INLINE uint32_t GPIO_ReadPort(GPIO_TypeDef* GPIOx)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
|
||||
return READ_REG(GPIOx->DATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение состояния младшего байта порта c использованием маски
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param MaskVal Значение маски чтения
|
||||
* @retval Val Состояние находится в битах 7:0
|
||||
*/
|
||||
__STATIC_INLINE uint32_t GPIO_ReadLowMask(GPIO_TypeDef* GPIOx, uint32_t MaskVal)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_MASK(MaskVal));
|
||||
|
||||
return READ_REG(GPIOx->MASKLB[MaskVal].MASKLB);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение состояния старшего байта порта c использованием маски
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param MaskVal Значение маски чтения
|
||||
* @retval Val Состояние находится в битах 15:8
|
||||
*/
|
||||
__STATIC_INLINE uint32_t GPIO_ReadHighMask(GPIO_TypeDef* GPIOx, uint32_t MaskVal)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_MASK(MaskVal));
|
||||
|
||||
return READ_REG(GPIOx->MASKHB[MaskVal].MASKHB);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Write Запись
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Запись выбранного пина
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пина
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_WriteBit(GPIO_TypeDef* GPIOx, uint32_t Pin, BitState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GET_GPIO_PIN(Pin));
|
||||
assert_param(IS_BIT_STATE(State));
|
||||
|
||||
MODIFY_REG(GPIOx->DATAOUT, Pin, State ? (uint32_t)Pin : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запись выбранного порта
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param PortVal Значение которое будет записано
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_WritePort(GPIO_TypeDef* GPIOx, uint32_t PortVal)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_VAL(PortVal));
|
||||
|
||||
WRITE_REG(GPIOx->DATAOUT, PortVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запись младшего байта порта c использованием маски
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param MaskVal Значение маски
|
||||
* @param PortVal Значение которое будет записано (биты 7:0)
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_WriteLowMask(GPIO_TypeDef* GPIOx, uint32_t MaskVal, uint32_t PortVal)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_VAL(PortVal));
|
||||
assert_param(IS_GPIO_MASK(MaskVal));
|
||||
|
||||
WRITE_REG(GPIOx->MASKLB[MaskVal].MASKLB, PortVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запись старшего байта порта c использованием маски
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param MaskVal Значение маски
|
||||
* @param PortVal Значение которое будет записано (биты 15:8)
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_WriteHighMask(GPIO_TypeDef* GPIOx, uint32_t MaskVal, uint32_t PortVal)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_VAL(PortVal));
|
||||
assert_param(IS_GPIO_MASK(MaskVal));
|
||||
|
||||
WRITE_REG(GPIOx->MASKHB[MaskVal].MASKHB, PortVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Bit_Operations Битовые операции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Установка пинов порта
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пина
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GET_GPIO_PIN(Pin));
|
||||
|
||||
WRITE_REG(GPIOx->DATAOUTSET, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс пинов порта
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пина
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ClearBits(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GET_GPIO_PIN(Pin));
|
||||
|
||||
WRITE_REG(GPIOx->DATAOUTCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Переключение пинов порта в противоположное состояние
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пина
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ToggleBits(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GET_GPIO_PIN(Pin));
|
||||
|
||||
WRITE_REG(GPIOx->DATAOUTTGL, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Qualifier Фильтрация
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка режима входного фильтра пина
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_QualModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_QualMode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_QUAL_MODE(Mode));
|
||||
|
||||
if (Mode == GPIO_QualMode_6Sample)
|
||||
WRITE_REG(GPIOx->QUALMODESET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->QUALMODECLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка времени сэмплирования
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param SamplePerod Количество тактов системной частоты между отсчетами фильтра
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_QualSampleConfig(GPIO_TypeDef* GPIOx, uint32_t SamplePerod)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_QUAL_PERIOD(SamplePerod));
|
||||
|
||||
WRITE_REG(GPIOx->QUALSAMPLE, SamplePerod);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение входных фильтров пинов
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_QualCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->QUALSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->QUALCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение пересинхронизации входов через 2 триггера
|
||||
* @param GPIOx выбор порта, где x=A|B.
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_SyncCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->SYNCSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->SYNCCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Interrupts Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка режима генерации сигналов прерываний и внешних сигналов запросов
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param IntType Выбор режима генерации
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ITTypeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_IntType_TypeDef IntType)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_INT_TYPE(IntType));
|
||||
|
||||
if (IntType == GPIO_IntType_Edge)
|
||||
WRITE_REG(GPIOx->INTTYPESET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->INTTYPECLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка полярности генерации прерываний
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param IntPol Выбор полярности
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ITPolConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_IntPol_TypeDef IntPol)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_INT_POL(IntPol));
|
||||
|
||||
if (IntPol == GPIO_IntPol_Positive)
|
||||
WRITE_REG(GPIOx->INTPOLSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->INTPOLCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима прерываний по перепадам
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param IntEdge Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ITEdgeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_IntEdge_TypeDef IntEdge)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_INT_EDGE(IntEdge));
|
||||
|
||||
if (IntEdge == GPIO_IntEdge_Any)
|
||||
WRITE_REG(GPIOx->INTEDGESET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->INTEDGECLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации прерываний
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ITCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->INTENSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->INTENCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение статуса выбранного пина
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @retval Status Если выбрано несколько пинов, то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus GPIO_ITStatus(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
|
||||
return (FlagStatus)READ_BIT(GPIOx->INTSTATUS, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса выбранного флага прерывания
|
||||
* @param Pin Выбор пинов
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ITStatusClear(GPIO_TypeDef* GPIOx, uint32_t Pin)
|
||||
{
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
|
||||
WRITE_REG(GPIOx->INTSTATUS, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_ExternalRequests Генерация внешних запросов
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации запросов к DMA
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_DMAReqCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->DMAREQSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->DMAREQCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации сигналов запуска АЦП
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_ADCSOCCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->ADCSOCSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->ADCSOCCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации события RXEV
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_RXEVCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->RXEVSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->RXEVCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Lock Механизм защиты конфигурации
|
||||
* @{
|
||||
*/
|
||||
/**
|
||||
* @brief Разрешение изменения состояния защиты пинов. Разрешение применяется спустя несколько тактов.
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_LockKeyCmd(GPIO_TypeDef* GPIOx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->LOCKKEY, (uint32_t)GPIO_LOCKKEY_VAL_UNLOCK);
|
||||
else
|
||||
WRITE_REG(GPIOx->LOCKKEY, (uint32_t)GPIO_LOCKKEY_VAL_LOCK);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Управление защитой конфигурации пина от изменений.
|
||||
* @attention По умолчанию, регистры используемые в функции находятся врежиме "только чтение".
|
||||
* Чтобы разрешить их запись, необходимо воспользоваться функцией @ref GPIO_LockKeyCmd и подождать несколько тактов.
|
||||
* @param GPIOx выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void GPIO_LockCmd(GPIO_TypeDef* GPIOx, uint32_t Pin, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == ENABLE)
|
||||
WRITE_REG(GPIOx->LOCKSET, Pin);
|
||||
else
|
||||
WRITE_REG(GPIOx->LOCKCLR, Pin);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_GPIO_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
548
MDK-ARM/platform/plib035/inc/plib035_i2c.h
Normal file
548
MDK-ARM/platform/plib035/inc/plib035_i2c.h
Normal file
@@ -0,0 +1,548 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_i2c.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* I2C, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_I2C_H
|
||||
#define __PLIB035_I2C_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
//extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup I2C
|
||||
* @brief Драйвер для работы с I2C
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Коды состояния I2C
|
||||
*/
|
||||
typedef enum {
|
||||
I2C_State_IDLE = I2C_ST_MODE_IDLE, /*!< Общий - Idle, нет доступной статусной информации */
|
||||
I2C_State_STDONE = I2C_ST_MODE_STDONE, /*!< FS мастер - Сформировано состояние СТАРТа */
|
||||
I2C_State_RSDONE = I2C_ST_MODE_RSDONE, /*!< FS мастер - Сформировано состояние повторного СТАРТа */
|
||||
I2C_State_IDLARL = I2C_ST_MODE_IDLARL, /*!< FS мастер - Потеря арбитража, переход в режим безадресного ведомого */
|
||||
I2C_State_MTADPA = I2C_ST_MODE_MTADPA, /*!< FS мастер передача - Отправлен адрес ведомого, ACK */
|
||||
I2C_State_MTADNA = I2C_ST_MODE_MTADNA, /*!< FS мастер передача - Отправлен адрес ведомого, NACK */
|
||||
I2C_State_MTDAPA = I2C_ST_MODE_MTDAPA, /*!< FS мастер передача - Отправлен байт данных, ACK */
|
||||
I2C_State_MTDANA = I2C_ST_MODE_MTDANA, /*!< FS мастер передача - Отправлен байт данных, NACK */
|
||||
I2C_State_MRADPA = I2C_ST_MODE_MRADPA, /*!< FS мастер приём - Отправлен адрес ведомого, ACK */
|
||||
I2C_State_MRADNA = I2C_ST_MODE_MRADNA, /*!< FS мастер приём - Отправлен адрес ведомого, NACK */
|
||||
I2C_State_MRDAPA = I2C_ST_MODE_MRDAPA, /*!< FS мастер приём - Принят байт данных, ACK */
|
||||
I2C_State_MRDANA = I2C_ST_MODE_MRDANA, /*!< FS мастер приём - Принят байт данных, NACK */
|
||||
I2C_State_MTMCER = I2C_ST_MODE_MTMCER, /*!< FS мастер - Отправлен код мастера, обнаружена ошибка, ACK */
|
||||
I2C_State_SRADPA = I2C_ST_MODE_SRADPA, /*!< FS ведомый приём - Принят адрес ведомого, ACK */
|
||||
I2C_State_SRAAPA = I2C_ST_MODE_SRAAPA, /*!< FS ведомый приём - Принят адрес ведомого после потери арбитража, ACK */
|
||||
I2C_State_SRDAPA = I2C_ST_MODE_SRDAPA, /*!< FS ведомый приём - Принят байт данных, ACK */
|
||||
I2C_State_SRDANA = I2C_ST_MODE_SRDANA, /*!< FS ведомый приём - Принят байт данных, NACK */
|
||||
I2C_State_STADPA = I2C_ST_MODE_STADPA, /*!< FS ведомый передача - Принят адрес ведомого, ACK */
|
||||
I2C_State_STAAPA = I2C_ST_MODE_STAAPA, /*!< FS ведомый передача - Принят адрес ведомого, NACK */
|
||||
I2C_State_STDAPA = I2C_ST_MODE_STDAPA, /*!< FS ведомый передача - Отправлен байт данных, ACK */
|
||||
I2C_State_STDANA = I2C_ST_MODE_STDANA, /*!< FS ведомый передача - Отправлен байт данных, NACK */
|
||||
I2C_State_SATADP = I2C_ST_MODE_SATADP, /*!< FS ведомый передача отклика на тревогу - Принят адрес отклика на тревогу, ACK */
|
||||
I2C_State_SATAAP = I2C_ST_MODE_SATAAP, /*!< FS ведомый передача отклика на тревогу - Принят адрес отклика на тревогу после потери арбитража, ACK */
|
||||
I2C_State_SATDAP = I2C_ST_MODE_SATDAP, /*!< FS ведомый передача отклика на тревогу - Отправлен байт данных отклика на тревогу, ACK */
|
||||
I2C_State_SATDAN = I2C_ST_MODE_SATDAN, /*!< FS ведомый передача отклика на тревогу - Отправлен байт данных отклика на тревогу, NACK */
|
||||
I2C_State_SSTOP = I2C_ST_MODE_SSTOP, /*!< FS ведомый - Обнаружено состояние СТОП ведомого */
|
||||
I2C_State_SGADPA = I2C_ST_MODE_SGADPA, /*!< FS ведомый - Принят адрес общего вызова, ACK */
|
||||
I2C_State_SDAAPA = I2C_ST_MODE_SDAAPA, /*!< FS ведомый - Принят адрес общего вызова после потери арбитража, ACK */
|
||||
I2C_State_BERROR = I2C_ST_MODE_BERROR, /*!< Общий - Обнаружена ошибка шины (некорректный СТАРТ или СТОП) */
|
||||
I2C_State_HMTMCOK = I2C_ST_MODE_HMTMCOK, /*!< HS мастер - Код мастера передан успешно - переход в режим HS */
|
||||
I2C_State_HRSDONE = I2C_ST_MODE_HRSDONE, /*!< HS мастер - Сформировано состояние повторного СТАРТа */
|
||||
I2C_State_HIDLARL = I2C_ST_MODE_HIDLARL, /*!< HS мастер - Потеря арбитража, переход в режим HS безадресного ведомого */
|
||||
I2C_State_HMTADPA = I2C_ST_MODE_HMTADPA, /*!< HS мастер передача - Отправлен адрес ведомого, ACK */
|
||||
I2C_State_HMTADNA = I2C_ST_MODE_HMTADNA, /*!< HS мастер передача - Отправлен адрес ведомого, NACK */
|
||||
I2C_State_HMTDAPA = I2C_ST_MODE_HMTDAPA, /*!< HS мастер передача - Отправлен байт данных, ACK */
|
||||
I2C_State_HMTDANA = I2C_ST_MODE_HMTDANA, /*!< HS мастер передача - Отправлен байт данных, NACK */
|
||||
I2C_State_HMRADPA = I2C_ST_MODE_HMRADPA, /*!< HS мастер приём - Отправлен адрес ведомого, ACK */
|
||||
I2C_State_HMRADNA = I2C_ST_MODE_HMRADNA, /*!< HS мастер приём - Отправлен адрес ведомого, NACK */
|
||||
I2C_State_HMRDAPA = I2C_ST_MODE_HMRDAPA, /*!< HS мастер приём - Принят байт данных, ACK */
|
||||
I2C_State_HMRDANA = I2C_ST_MODE_HMRDANA, /*!< HS мастер приём - Принят байт данных, NACK */
|
||||
I2C_State_HSRADPA = I2C_ST_MODE_HSRADPA, /*!< HS ведомый приём - Принят адрес ведомого, ACK */
|
||||
I2C_State_HSRDAPA = I2C_ST_MODE_HSRDAPA, /*!< HS ведомый приём - Принят байт данных, ACK */
|
||||
I2C_State_HSRDANA = I2C_ST_MODE_HSRDANA, /*!< HS ведомый приём - Принят байт данных, NACK */
|
||||
I2C_State_HSTADPA = I2C_ST_MODE_HSTADPA, /*!< HS ведомый передача - Принят адрес ведомого, ACK */
|
||||
I2C_State_HSTDAPA = I2C_ST_MODE_HSTDAPA, /*!< HS ведомый передача - Отправлен байт данных, ACK */
|
||||
I2C_State_HSTDANA = I2C_ST_MODE_HSTDANA, /*!< HS ведомый передача - Отправлен байт данных, NACK */
|
||||
} I2C_State_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Выбор предделителя тактовой частоты для счетчика простоя линии SCL
|
||||
*/
|
||||
typedef enum {
|
||||
I2C_TimeoutClkDiv_Disable = I2C_CST_TOCDIV_Disable, /*!< Выключен, не тактируется */
|
||||
I2C_TimeoutClkDiv_Div4 = I2C_CST_TOCDIV_Div4, /*!< Деление на 4 */
|
||||
I2C_TimeoutClkDiv_Div8 = I2C_CST_TOCDIV_Div8, /*!< Деление на 8 */
|
||||
I2C_TimeoutClkDiv_Div16 = I2C_CST_TOCDIV_Div16 /*!< Деление на 16 */
|
||||
} I2C_TimeoutClkDiv_TypeDef;
|
||||
#define IS_I2C_TIMEOUT_CLK_DIV(VALUE) (((VALUE) == I2C_TimeoutClkDiv_Disable) || \
|
||||
((VALUE) == I2C_TimeoutClkDiv_Div4) || \
|
||||
((VALUE) == I2C_TimeoutClkDiv_Div8) || \
|
||||
((VALUE) == I2C_TimeoutClkDiv_Div16))
|
||||
|
||||
#define IS_I2C_TIMEOUT_LOAD_VAL(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_I2C_DATA_VAL(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_I2C_FS_DIV_LOW_VAL(VALUE) (((VALUE) < 0x80) && ((VALUE) > 0x3))
|
||||
#define IS_I2C_FS_DIV_HIGH_VAL(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_I2C_HS_DIV_LOW_VAL(VALUE) (((VALUE) < 0x10) && ((VALUE) > 0x1))
|
||||
#define IS_I2C_HS_DIV_HIGH_VAL(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_I2C_SLAVE_ADDR_VAL(VALUE) ((VALUE) < 0x80)
|
||||
#define IS_I2C_SLAVE_10_ADDR_VAL(VALUE) ((VALUE) < 0x8)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions_Clk Настройка тактирования
|
||||
* @{
|
||||
*/
|
||||
|
||||
void I2C_FSFreqConfig(uint32_t FSFreq, uint32_t I2CFreq);
|
||||
void I2C_HSFreqConfig(uint32_t HSFreq, uint32_t I2CFreq);
|
||||
|
||||
/**
|
||||
* @brief Установка младшей части делителя частоты в режиме FS мастера.
|
||||
* @attention Можно записать любое значение в диапазоне от 4 до 127. При попытке
|
||||
* записи любого значения меньше 4, оно будет записано со смещением 4.
|
||||
* Например, при записи числа 2, к нему будет аппаратно добавлено
|
||||
* смещение 4 и, в итоге, в регистре окажется значение 6.
|
||||
* @param DivVal Значение (биты [6:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_FSDivLowConfig(uint32_t DivVal)
|
||||
{
|
||||
assert_param(IS_I2C_FS_DIV_LOW_VAL(DivVal));
|
||||
|
||||
WRITE_REG(I2C->CTL1_bit.SCLFRQ, DivVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка старшей части делителя частоты в режиме FS мастера
|
||||
* @param DivVal Значение (биты [7:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_FSDivHighConfig(uint32_t DivVal)
|
||||
{
|
||||
assert_param(IS_I2C_FS_DIV_HIGH_VAL(DivVal));
|
||||
|
||||
WRITE_REG(I2C->CTL3_bit.SCLFRQ, DivVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка младшей части делителя частоты в режиме HS мастера.
|
||||
* @attention Можно записать любое значение в диапазоне от 2 до 15. При попытке
|
||||
* записи любого значения меньше 2, оно будет записано со смещением 2.
|
||||
* Например, при записи числа 1, к нему будет аппаратно добавлено
|
||||
* смещение 2 и, в итоге, в регистре окажется значение 3.
|
||||
* @param DivVal Значение (биты [3:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_HSDivLowConfig(uint32_t DivVal)
|
||||
{
|
||||
assert_param(IS_I2C_HS_DIV_LOW_VAL(DivVal));
|
||||
|
||||
WRITE_REG(I2C->CTL2_bit.HSDIV, DivVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка старшей части делителя частоты в режиме HS мастера
|
||||
* @param DivVal Значение (биты [7:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_HSDivHighConfig(uint32_t DivVal)
|
||||
{
|
||||
assert_param(IS_I2C_HS_DIV_HIGH_VAL(DivVal));
|
||||
|
||||
WRITE_REG(I2C->CTL4_bit.HSDIV, DivVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions_CtrlStatus Общее управление и статусная информация
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение модуля I2C
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->CTL1_bit.ENABLE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение состояния внутренней машины состояний I2C
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE I2C_State_TypeDef I2C_GetState(void)
|
||||
{
|
||||
return (I2C_State_TypeDef)READ_REG(I2C->ST_bit.MODE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка байта данных I2C
|
||||
* @param DataVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_SetData(uint32_t DataVal)
|
||||
{
|
||||
assert_param(IS_I2C_DATA_VAL(DataVal));
|
||||
|
||||
WRITE_REG(I2C->SDA, DataVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение байта данных I2C
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t I2C_GetData(void)
|
||||
{
|
||||
return READ_REG(I2C->SDA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага занятости шины
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus I2C_BusBusyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(I2C->CST, I2C_CST_BB_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага ошибки сравнения контрольной суммы
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus I2C_PECFailStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(I2C->CST, I2C_CST_PECFAULT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение текущего состояния линии SDA
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus I2C_SDAStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(I2C->CST, I2C_CST_TSDA_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение режима распознавания адреса отклика на тревогу
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_AlertResponseMatchCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->CTL0_bit.SMBARE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение режима распознавания адреса общего вызова
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_GlobalCallMatchCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->CTL0_bit.GCMEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Следующий переданный/принятый байт будет байтом контрольной суммы
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_PECCmd(void)
|
||||
{
|
||||
WRITE_REG(I2C->CST_bit.PECNEXT, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Принудительное переключение сигнала SCL на один такт, когда на SDA низкий уровень
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_ToggleSCL(void)
|
||||
{
|
||||
WRITE_REG(I2C->CST_bit.TGSCL, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Формирование состояния СТАРТ
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_StartCmd(void)
|
||||
{
|
||||
WRITE_REG(I2C->CTL0_bit.START, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Формирование состояния СТОП
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_StopCmd(void)
|
||||
{
|
||||
WRITE_REG(I2C->CTL0_bit.STOP, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Передача значения NACK в ответе на запрос передатчика
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_NACKCmd(void)
|
||||
{
|
||||
WRITE_REG(I2C->CTL0_bit.ACK, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions_SlaveMode Управление режимом ведомого
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение режима распознавания принятого адреса (режим ведомого)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_SlaveCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->ADDR_bit.SAEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание собственного адреса ведомого
|
||||
* @param AddrVal Значение адреса (биты [6:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_SetSlaveAddr(uint32_t AddrVal)
|
||||
{
|
||||
assert_param(IS_I2C_SLAVE_ADDR_VAL(AddrVal));
|
||||
|
||||
WRITE_REG(I2C->ADDR_bit.ADDR, AddrVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение собственного адреса ведомого
|
||||
* @retval Val Значение адреса (биты [6:0])
|
||||
*/
|
||||
__STATIC_INLINE uint32_t I2C_GetSlaveAddr(void)
|
||||
{
|
||||
return READ_REG(I2C->ADDR_bit.ADDR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение режима 10-битной адресации ведомого
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_Slave10AddrCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->CTL2_bit.S10EN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание старшей части 10-битного адреса ведомого.
|
||||
* Два байта адреса формируются следующим образом:
|
||||
* [11110b, S10ADDR[2:1]] и [S10ADDR[0], ADDR[6:0]].
|
||||
* @param AddrVal Значение адреса (биты [2:0])
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_SetSlave10Addr(uint32_t Addr10Val)
|
||||
{
|
||||
assert_param(IS_I2C_SLAVE_10_ADDR_VAL(Addr10Val));
|
||||
|
||||
WRITE_REG(I2C->CTL2_bit.S10ADR, Addr10Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение старшей части 10-битного адреса ведомого
|
||||
* @retval Val Значение адреса (биты [2:0])
|
||||
*/
|
||||
__STATIC_INLINE uint32_t I2C_GetSlave10Addr(void)
|
||||
{
|
||||
return READ_REG(I2C->CTL2_bit.S10ADR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions_Timeout Контроль простоя шины
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает коэффициент деления тактового сигнала,
|
||||
* подаваемого на предделитель времени простоя линии SCL
|
||||
* @param TimeoutClkDiv Выбор делителя
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_TimeoutClkDivConfig(I2C_TimeoutClkDiv_TypeDef TimeoutClkDiv)
|
||||
{
|
||||
assert_param(IS_I2C_TIMEOUT_CLK_DIV(TimeoutClkDiv));
|
||||
|
||||
WRITE_REG(I2C->CST_bit.TOCDIV, TimeoutClkDiv);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения загрузки счетчика времени простоя
|
||||
* @param LoadVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_SetTimeoutCounterLoad(uint32_t LoadVal)
|
||||
{
|
||||
assert_param(IS_I2C_TIMEOUT_LOAD_VAL(LoadVal));
|
||||
|
||||
WRITE_REG(I2C->TOPR, LoadVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения загрузки счетчика времени простоя
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t I2C_GetTimeoutCounterLoad(void)
|
||||
{
|
||||
return READ_REG(I2C->TOPR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага ошибки простоя I2C
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus I2C_TimeoutStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(I2C->CST, I2C_CST_TOERR_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага ошибки простоя I2C
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_TimeoutStatusClear(void)
|
||||
{
|
||||
WRITE_REG(I2C->CTL0_bit.CLRST, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Exported_Functions_IT Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение генерации прерывания I2C
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_ITCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(I2C->CTL0_bit.INTEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага прерывания I2C
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus I2C_ITStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(I2C->ST, I2C_ST_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага прерывания I2C
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void I2C_ITStatusClear(void)
|
||||
{
|
||||
WRITE_REG(I2C->CTL0_bit.CLRST, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_I2C_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
327
MDK-ARM/platform/plib035/inc/plib035_mflash.h
Normal file
327
MDK-ARM/platform/plib035/inc/plib035_mflash.h
Normal file
@@ -0,0 +1,327 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_mflash.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* MFLASH, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_MFLASH_H
|
||||
#define __PLIB035_MFLASH_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH
|
||||
* @brief Драйвер для работы с MFLASH
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Команды контроллера флеш-памяти
|
||||
*/
|
||||
typedef enum {
|
||||
MFLASH_Cmd_Read = MFLASH_CMD_RD_Msk, /*!< Команда чтения */
|
||||
MFLASH_Cmd_Write = MFLASH_CMD_WR_Msk, /*!< Команда записи */
|
||||
MFLASH_Cmd_EraseFull = MFLASH_CMD_ERALL_Msk, /*!< Команда стирания всей памяти */
|
||||
MFLASH_Cmd_ErasePage = MFLASH_CMD_ERSEC_Msk, /*!< Команда стирания страницы */
|
||||
} MFLASH_Cmd_TypeDef;
|
||||
#define IS_MFLASH_CMD(VALUE) (((VALUE) == MFLASH_Cmd_Read) || \
|
||||
((VALUE) == MFLASH_Cmd_Write) || \
|
||||
((VALUE) == MFLASH_Cmd_EraseFull) || \
|
||||
((VALUE) == MFLASH_Cmd_ErasePage))
|
||||
|
||||
/**
|
||||
* @brief Выбор региона флеш-памяти для исполнения команд
|
||||
*/
|
||||
typedef enum {
|
||||
MFLASH_Region_Main = 0UL, /*!< Основная область */
|
||||
MFLASH_Region_NVR = MFLASH_CMD_NVRON_Msk, /*!< NVR область (загрузочная) */
|
||||
} MFLASH_Region_TypeDef;
|
||||
#define IS_MFLASH_REGION(VALUE) (((VALUE) == MFLASH_Region_Main) || \
|
||||
((VALUE) == MFLASH_Region_NVR))
|
||||
|
||||
#define IS_MFLASH_MAIN_ADDR(MAIN_ADDR) (MAIN_ADDR < MEM_MFLASH_SIZE)
|
||||
#define IS_MFLASH_MAIN_PAGE_NUM(MAIN_PAGE_NUM) (MAIN_PAGE_NUM < MEM_MFLASH_PAGE_TOTAL)
|
||||
#define IS_MFLASH_NVR_ADDR(NVR_ADDR) (NVR_ADDR < MEM_MFLASH_NVR_SIZE)
|
||||
#define IS_MFLASH_NVR_PAGE_NUM(NVR_PAGE_NUM) (NVR_PAGE_NUM < MEM_MFLASH_NVR_PAGE_TOTAL)
|
||||
#define IS_MFLASH_DATA_NUM(DATA_NUM) (DATA_NUM < MEM_MFLASH_BUS_WIDTH_WORDS)
|
||||
#define IS_MFLASH_LATENCY(LATENCY) (LATENCY < 15)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Cmd Управление контроллером флеш-памяти
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Установка значения адреса
|
||||
* @param AddrVal Значение адреса
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_SetAddr(uint32_t AddrVal)
|
||||
{
|
||||
WRITE_REG(MFLASH->ADDR, AddrVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка выбранного слова данных
|
||||
* @param DataNum Номер слова данных
|
||||
* @param DataVal Значение слова данных
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_SetData(uint32_t DataNum, uint32_t DataVal)
|
||||
{
|
||||
assert_param(IS_MFLASH_DATA_NUM(DataNum));
|
||||
|
||||
WRITE_REG(MFLASH->DATA[DataNum].DATA, DataVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение выбранного слова данных
|
||||
* @param DataNum Номер слова данных
|
||||
* @retval Val Значение слова данных
|
||||
*/
|
||||
__STATIC_INLINE uint32_t MFLASH_GetData(uint32_t DataNum)
|
||||
{
|
||||
assert_param(IS_MFLASH_DATA_NUM(DataNum));
|
||||
|
||||
return READ_REG(MFLASH->DATA[DataNum].DATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Передача команды контроллеру флеш-памяти
|
||||
* @param Cmd Команда
|
||||
* @param Region Область
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_SetCmd(MFLASH_Cmd_TypeDef Cmd, MFLASH_Region_TypeDef Region)
|
||||
{
|
||||
WRITE_REG(MFLASH->CMD, ((uint32_t)MFLASH_CMD_KEY_Access << MFLASH_CMD_KEY_Pos) | (uint32_t)Region | (uint32_t)Cmd);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение статуса занятости контроллера флеш-памяти
|
||||
* @retval Status
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus MFLASH_BusyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(MFLASH->STAT, MFLASH_STAT_BUSY_Msk);
|
||||
}
|
||||
|
||||
void MFLASH_ReadData(uint32_t AddrVal, uint32_t* DataArr, MFLASH_Region_TypeDef Region);
|
||||
void MFLASH_WriteData(uint32_t AddrVal, uint32_t* DataArr, MFLASH_Region_TypeDef Region);
|
||||
void MFLASH_ErasePage(uint32_t AddrVal, MFLASH_Region_TypeDef Region);
|
||||
void MFLASH_EraseFull(MFLASH_Region_TypeDef Region);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_ExecCtrl Настройка исполнения программ
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка количества тактов ожидания чтения из флеш
|
||||
* @param LatencyVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_LatencyConfig(uint32_t LatencyVal)
|
||||
{
|
||||
assert_param(IS_MFLASH_LATENCY(LatencyVal));
|
||||
|
||||
WRITE_REG(MFLASH->CTRL_bit.LAT, LatencyVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы кэша инструкций
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_ICacheCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(MFLASH->CTRL_bit.ICEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Очистка кэша инструкций
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_ICacheFlushCmd(void)
|
||||
{
|
||||
WRITE_REG(MFLASH->CTRL_bit.IFLUSH, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение статуса занятости очистки кэша инструкций
|
||||
* @retval Status
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus MFLASH_ICacheBusyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(MFLASH->ICSTAT, MFLASH_ICSTAT_BUSY_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы кэша данных
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_DCacheCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(MFLASH->CTRL_bit.DCEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Очистка кэша данных
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_DCacheFlushCmd(void)
|
||||
{
|
||||
WRITE_REG(MFLASH->CTRL_bit.DFLUSH, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение статуса занятости очистки кэша данных
|
||||
* @retval Status
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus MFLASH_DCacheBusyStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(MFLASH->DCSTAT, MFLASH_DCSTAT_BUSY_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы предвыборки
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_PrefetchCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(MFLASH->CTRL_bit.PEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Отключение старта из загрузчоной памяти после следующего программного сброса.
|
||||
* Оказывает влияние только если в CFGWORD активирован старт из загрузочной области.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_BootDisableCmd(void)
|
||||
{
|
||||
WRITE_REG(MFLASH->BDIS, MFLASH_BDIS_BMDIS_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_IRQ Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы прерывания MFLASH
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_ITCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(MFLASH->CTRL_bit.IRQEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение статуса прерывания
|
||||
* @retval Status
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus MFLASH_ITStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(MFLASH->STAT, MFLASH_STAT_IRQF_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса прерывания
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void MFLASH_ITStatusClear(void)
|
||||
{
|
||||
WRITE_REG(MFLASH->STAT, MFLASH_STAT_IRQF_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_MFLASH_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
162
MDK-ARM/platform/plib035/inc/plib035_pmu.h
Normal file
162
MDK-ARM/platform/plib035/inc/plib035_pmu.h
Normal file
@@ -0,0 +1,162 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_pmu.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* PMU, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_PMU_H
|
||||
#define __PLIB035_PMU_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PMU
|
||||
* @brief Драйвер для работы с PMU
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Управление режимом powerdown выбранного блока периферии
|
||||
*/
|
||||
typedef enum {
|
||||
PMU_PeriphPD_PLL = PMU_PDEN_PLLPD_Msk, /*!< Управление режимом powerdown PLL */
|
||||
PMU_PeriphPD_MFLASH = PMU_PDEN_MFLASHPD_Msk, /*!< Управление режимом powerdown MFLASH */
|
||||
PMU_PeriphPD_OSE = PMU_PDEN_OSEPD_Msk /*!< Управление режимом powerdown OSE */
|
||||
} PMU_PeriphPD_TypeDef;
|
||||
#define IS_PMU_PERIPH_PD(VALUE) (((VALUE) == PMU_PeriphPD_PLL) || \
|
||||
((VALUE) == PMU_PeriphPD_MFLASH) || \
|
||||
((VALUE) == PMU_PeriphPD_OSE))
|
||||
|
||||
/**
|
||||
* @brief Управление разрешением получения событий RXEV от портов
|
||||
*/
|
||||
typedef enum {
|
||||
PMU_RXEV_GPIOA = PMU_RXEVEN_GPIOAEV_Msk, /*!< Управление разрешением получения событий RXEV от GPIOA */
|
||||
PMU_RXEV_GPIOB = PMU_RXEVEN_GPIOBEV_Msk, /*!< Управление разрешением получения событий RXEV от GPIOB */
|
||||
} PMU_RXEV_TypeDef;
|
||||
#define IS_PMU_RXEV(VALUE) (((VALUE) == PMU_RXEV_GPIOA) || \
|
||||
((VALUE) == PMU_RXEV_GPIOB))
|
||||
|
||||
#define IS_PMU_POWERUP_DELAY(VALUE) (((VALUE)&0xFFFF0000) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы PMU - необходимо для перехода в режим Deepsleep
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PMU_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PMU->CFG_bit.EN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка задержки выхода из сна в тактах OSI
|
||||
* @param DelayVal Величина хадержки
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PMU_PowerUpDelayConfig(uint32_t DelayVal)
|
||||
{
|
||||
assert_param(IS_PMU_POWERUP_DELAY(DelayVal));
|
||||
|
||||
WRITE_REG(PMU->PUDEL, DelayVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Управление режимом powerdown выбранного блока периферии
|
||||
* @param PeriphPD Выбор периферии
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PMU_PeriphPDCmd(PMU_PeriphPD_TypeDef PeriphPD, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PMU_PERIPH_PD(PeriphPD));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(PMU->PDEN, PeriphPD, State ? (uint32_t)PeriphPD : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Управление разрешением получения событий RXEV от портов
|
||||
* @param RXEV Выбор порта
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PMU_RXEVCmd(PMU_RXEV_TypeDef RXEV, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PMU_RXEV(RXEV));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(PMU->RXEVEN, RXEV, State ? (uint32_t)RXEV : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_PMU_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
2038
MDK-ARM/platform/plib035/inc/plib035_pwm.h
Normal file
2038
MDK-ARM/platform/plib035/inc/plib035_pwm.h
Normal file
@@ -0,0 +1,2038 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_pwm.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* PWM, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_PWM_H
|
||||
#define __PLIB035_PWM_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PWM
|
||||
* @brief Драйвер для работы с PWM
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_TB_Status_Define Статусы счетчика
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_TB_Status_CountDir PWM_TBSTS_CTRDIR_Msk /*!< Направление счета */
|
||||
#define PWM_TB_Status_SyncIn PWM_TBSTS_SYNCI_Msk /*!< Произошло событие синхронизации */
|
||||
#define PWM_TB_Status_CountMax PWM_TBSTS_CTRMAX_Msk /*!< Таймер достиг максимального значения 0xFFFF */
|
||||
#define PWM_TB_Status_All (PWM_TB_Status_CountDir | \
|
||||
PWM_TB_Status_SyncIn | \
|
||||
PWM_TB_Status_CountMax) /*!< Все статусы выбраны */
|
||||
|
||||
#define IS_PWM_TB_STATUS(VALUE) (((VALUE) & ~PWM_TB_Status_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_CMP_Status_Define Статусы компаратора
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_CMP_Status_ShadowLoadedA PWM_CMPCTL_SHDWAFULL_Msk /*!< Произошла теневая загрузка в CMPA */
|
||||
#define PWM_CMP_Status_ShadowLoadedB PWM_CMPCTL_SHDWBFULL_Msk /*!< Произошла теневая загрузка в CMPB */
|
||||
#define PWM_CMP_Status_All (PWM_CMP_Status_ShadowLoadedA | \
|
||||
PWM_CMP_Status_ShadowLoadedB) /*!< Все статусы выбраны */
|
||||
|
||||
#define IS_PWM_CMP_STATUS(VALUE) (((VALUE) & ~PWM_CMP_Status_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Presc_Define Управление предделителями таймеров блоков ШИМ
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_TB_Presc_0 (0x1UL << SIU_PWMSYNC_PRESCRST_Pos) /*!< Предделитель блока ШИМ0 */
|
||||
#define PWM_TB_Presc_1 (0x2UL << SIU_PWMSYNC_PRESCRST_Pos) /*!< Предделитель блока ШИМ1 */
|
||||
#define PWM_TB_Presc_2 (0x4UL << SIU_PWMSYNC_PRESCRST_Pos) /*!< Предделитель блока ШИМ2 */
|
||||
#define PWM_TB_Presc_All (PWM_TB_Presc_0 | \
|
||||
PWM_TB_Presc_1 | \
|
||||
PWM_TB_Presc_2) /*!< Все блоки выбраны */
|
||||
|
||||
#define IS_PWM_TB_PRESC(VALUE) (((VALUE) & ~PWM_TB_Presc_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_TZ_ITSource_Define Источники прерываний блока сигналов аварий ШИМ
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_TZ_ITSource_Cycle PWM_TZEINT_CBC_Msk /*!< Циклический обработчик сигнала аварии */
|
||||
#define PWM_TZ_ITSource_OneShot PWM_TZEINT_OST_Msk /*!< Однократный обработчик сигнала аварии */
|
||||
#define PWM_TZ_ITSource_All (PWM_TZ_ITSource_Cycle | \
|
||||
PWM_TZ_ITSource_OneShot) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_PWM_TZ_IT_SOURCE(IT_SOURCE) (((IT_SOURCE) & ~PWM_TZ_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_TZ_ITStatus_Define Флаги прерываний блока сигналов аварий ШИМ
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_TZ_ITStatus_Int PWM_TZFLG_INT_Msk /*!< Флаг прерывания NVIC */
|
||||
#define PWM_TZ_ITStatus_Cycle PWM_TZFLG_CBC_Msk /*!< Циклический обработчик сигнала аварии */
|
||||
#define PWM_TZ_ITStatus_OneShot PWM_TZFLG_OST_Msk /*!< Однократный обработчик сигнала аварии */
|
||||
#define PWM_TZ_ITStatus_All (PWM_TZ_ITStatus_Int | \
|
||||
PWM_TZ_ITStatus_Cycle | \
|
||||
PWM_TZ_ITStatus_OneShot) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_PWM_TZ_IT_STATUS(VALUE) (((VALUE) & ~PWM_TZ_ITStatus_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_ET_Status_Define Флаги генерации событий запуска АЦП и DMA обработчиком событий
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_ET_Status_SOCA PWM_ETFLG_SOCA_Msk /*!< Флаг генерации запуска АЦП от канала А */
|
||||
#define PWM_ET_Status_SOCB PWM_ETFLG_SOCB_Msk /*!< Флаг генерации запуска АЦП от канала B */
|
||||
#define PWM_ET_Status_DRQA PWM_ETFLG_DRQA_Msk /*!< Флаг генерации запроса DMA от канала А */
|
||||
#define PWM_ET_Status_DRQB PWM_ETFLG_DRQB_Msk /*!< Флаг генерации запроса DMA от канала B */
|
||||
#define PWM_ET_Status_All (PWM_ET_Status_SOCA | \
|
||||
PWM_ET_Status_SOCB | \
|
||||
PWM_ET_Status_DRQA | \
|
||||
PWM_ET_Status_DRQB) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_PWM_ET_STATUS(VALUE) (((VALUE) & ~PWM_ET_Status_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_HD_Source_Define Выбор источника события удержания
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_HD_Source_ADCDC0 PWM_HDSEL_ADCDC0_Msk /*!< Сигнал от цифрового компаратора 0 АЦП */
|
||||
#define PWM_HD_Source_ADCDC1 PWM_HDSEL_ADCDC1_Msk /*!< Сигнал от цифрового компаратора 1 АЦП */
|
||||
#define PWM_HD_Source_ADCDC2 PWM_HDSEL_ADCDC2_Msk /*!< Сигнал от цифрового компаратора 2 АЦП */
|
||||
#define PWM_HD_Source_ADCDC3 PWM_HDSEL_ADCDC3_Msk /*!< Сигнал от цифрового компаратора 3 АЦП */
|
||||
#define PWM_HD_Source_All (PWM_HD_Source_ADCDC0 | \
|
||||
PWM_HD_Source_ADCDC1 | \
|
||||
PWM_HD_Source_ADCDC2 | \
|
||||
PWM_HD_Source_ADCDC3) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_PWM_HD_SOURCE(VALUE) (((VALUE) & ~PWM_HD_Source_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_HD_ITSource_Define Источники прерываний блока cобытий удержания
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_HD_ITSource_Cycle PWM_HDEINT_CBC_Msk /*!< Циклический обработчик cобытия удержания */
|
||||
#define PWM_HD_ITSource_OneShot PWM_HDEINT_OST_Msk /*!< Однократный обработчик cобытия удержания */
|
||||
#define PWM_HD_ITSource_All (PWM_HD_ITSource_Cycle | \
|
||||
PWM_HD_ITSource_OneShot) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_PWM_HD_IT_SOURCE(VALUE) (((VALUE) & ~PWM_HD_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_HD_ITStatus_Define Флаги прерываний блока cобытий удержания
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define PWM_HD_ITStatus_Int PWM_HDFLG_INT_Msk /*!< Флаг прерывания NVIC */
|
||||
#define PWM_HD_ITStatus_Cycle PWM_HDFLG_CBC_Msk /*!< Циклический обработчик cобытия удержания */
|
||||
#define PWM_HD_ITStatus_OneShot PWM_HDFLG_OST_Msk /*!< Однократный обработчик cобытия удержания */
|
||||
#define PWM_HD_ITStatus_All (PWM_HD_ITStatus_Int | \
|
||||
PWM_HD_ITStatus_Cycle | \
|
||||
PWM_HD_ITStatus_OneShot) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_PWM_HD_IT_STATUS(VALUE) (((VALUE) & ~PWM_HD_ITStatus_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#define IS_PWM_IT_PERIOD(VALUE) ((VALUE) < 0x4)
|
||||
#define IS_PWM_FILTER(VALUE) ((VALUE) < 0x100)
|
||||
#define IS_PWM_PC_DUTY(VALUE) ((VALUE) < 0x7)
|
||||
#define IS_PWM_PC_FREQ_DIV(VALUE) ((VALUE) < 0x8)
|
||||
#define IS_PWM_PC_FIRST_WIDTH(VALUE) ((VALUE) < 0x10)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор режима остановки таймера при отладке
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_Halt_StopOnTBCLK = PWM_TBCTL_FREESOFT_StopAtTBCLK, /*!< Остановка таймера при отладке со следующего такта TBCLK */
|
||||
PWM_TB_Halt_StopOnPeriod = PWM_TBCTL_FREESOFT_StopAtPeriod, /*!< Остановка таймера при отладке в конце периода */
|
||||
PWM_TB_Halt_Free = PWM_TBCTL_FREESOFT_FreeRun /*!< Без остановки */
|
||||
} PWM_TB_Halt_TypeDef;
|
||||
#define IS_PWM_TB_HALT(VALUE) (((VALUE) == PWM_TB_Halt_StopOnTBCLK) || \
|
||||
((VALUE) == PWM_TB_Halt_StopOnPeriod))
|
||||
|
||||
/**
|
||||
* @brief Коэффициент базового деления частоты
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_ClkDiv_1 = PWM_TBCTL_CLKDIV_Div1, /*!< Без деления тактовой частоты */
|
||||
PWM_TB_ClkDiv_2 = PWM_TBCTL_CLKDIV_Div2, /*!< Деление тактовой частоты на 2 */
|
||||
PWM_TB_ClkDiv_4 = PWM_TBCTL_CLKDIV_Div4, /*!< Деление тактовой частоты на 4 */
|
||||
PWM_TB_ClkDiv_8 = PWM_TBCTL_CLKDIV_Div8, /*!< Деление тактовой частоты на 8 */
|
||||
PWM_TB_ClkDiv_16 = PWM_TBCTL_CLKDIV_Div16, /*!< Деление тактовой частоты на 16 */
|
||||
PWM_TB_ClkDiv_32 = PWM_TBCTL_CLKDIV_Div32, /*!< Деление тактовой частоты на 32 */
|
||||
PWM_TB_ClkDiv_64 = PWM_TBCTL_CLKDIV_Div64, /*!< Деление тактовой частоты на 64 */
|
||||
PWM_TB_ClkDiv_128 = PWM_TBCTL_CLKDIV_Div128 /*!< Деление тактовой частоты на 128 */
|
||||
} PWM_TB_ClkDiv_TypeDef;
|
||||
#define IS_PWM_TB_CLK_DIV(VALUE) (((VALUE) == PWM_TB_ClkDiv_1) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_2) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_4) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_8) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_16) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_32) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_64) || \
|
||||
((VALUE) == PWM_TB_ClkDiv_128))
|
||||
|
||||
/**
|
||||
* @brief Коэффициент дополнительного деления частоты
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_ClkDivExtra_1 = PWM_TBCTL_HSPCLKDIV_Div1, /*!< Без дополнительного деления тактовой частоты */
|
||||
PWM_TB_ClkDivExtra_2 = PWM_TBCTL_HSPCLKDIV_Div2, /*!< Дополнительное деление тактовой частоты на 2 */
|
||||
PWM_TB_ClkDivExtra_4 = PWM_TBCTL_HSPCLKDIV_Div4, /*!< Дополнительное деление тактовой частоты на 4 */
|
||||
PWM_TB_ClkDivExtra_6 = PWM_TBCTL_HSPCLKDIV_Div6, /*!< Дополнительное деление тактовой частоты на 6 */
|
||||
PWM_TB_ClkDivExtra_8 = PWM_TBCTL_HSPCLKDIV_Div8, /*!< Дополнительное деление тактовой частоты на 8 */
|
||||
PWM_TB_ClkDivExtra_10 = PWM_TBCTL_HSPCLKDIV_Div10, /*!< Дополнительное деление тактовой частоты на 10 */
|
||||
PWM_TB_ClkDivExtra_12 = PWM_TBCTL_HSPCLKDIV_Div12, /*!< Дополнительное деление тактовой частоты на 12 */
|
||||
PWM_TB_ClkDivExtra_14 = PWM_TBCTL_HSPCLKDIV_Div14, /*!< Дополнительное деление тактовой частоты на 14 */
|
||||
} PWM_TB_ClkDivExtra_TypeDef;
|
||||
#define IS_PWM_TB_CLK_DIV_EXTRA(VALUE) (((VALUE) == PWM_TB_ClkDivExtra_1) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_2) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_4) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_6) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_8) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_10) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_12) || \
|
||||
((VALUE) == PWM_TB_ClkDivExtra_14))
|
||||
|
||||
/**
|
||||
* @brief Направление счета
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_Dir_Down, /*!< Счет вниз */
|
||||
PWM_TB_Dir_Up /*!< Счет вверх */
|
||||
} PWM_TB_Dir_TypeDef;
|
||||
#define IS_PWM_TB_DIR(VALUE) (((VALUE) == PWM_TB_Dir_Down) || \
|
||||
((VALUE) == PWM_TB_Dir_Up))
|
||||
|
||||
/**
|
||||
* @brief Источник для выходного сигнала синхронизации SYNCO
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_SyncOut_SyncIn = PWM_TBCTL_SYNCOSEL_SYNCI, /*!< Входной сигнал SYNCI */
|
||||
PWM_TB_SyncOut_CTREqZero = PWM_TBCTL_SYNCOSEL_CTREqZero, /*!< Значение таймера равно нулю */
|
||||
PWM_TB_SyncOut_CTREqCMPB = PWM_TBCTL_SYNCOSEL_CTREqCMPB, /*!< Значение таймера равно регистру CMPB */
|
||||
PWM_TB_SyncOut_Disable = PWM_TBCTL_SYNCOSEL_Disable /*!< Выдача синхроимпульса запрещена */
|
||||
} PWM_TB_SyncOut_TypeDef;
|
||||
#define IS_PWM_TB_SYNC_OUT(VALUE) (((VALUE) == PWM_TB_SyncOut_SyncIn) || \
|
||||
((VALUE) == PWM_TB_SyncOut_CTREqZero) || \
|
||||
((VALUE) == PWM_TB_SyncOut_CTREqCMPB) || \
|
||||
((VALUE) == PWM_TB_SyncOut_Disable))
|
||||
|
||||
/**
|
||||
* @brief Направление счета
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TB_Mode_Up = PWM_TBCTL_CTRMODE_Up, /*!< Счет вверх */
|
||||
PWM_TB_Mode_Down = PWM_TBCTL_CTRMODE_Down, /*!< Счет вниз */
|
||||
PWM_TB_Mode_UpDown = PWM_TBCTL_CTRMODE_UpDown, /*!< Счет вверх-вниз */
|
||||
PWM_TB_Mode_Disable = PWM_TBCTL_CTRMODE_Stop /*!< Счетчик остановлен */
|
||||
} PWM_TB_Mode_TypeDef;
|
||||
#define IS_PWM_TB_MODE(VALUE) (((VALUE) == PWM_TB_Mode_Up) || \
|
||||
((VALUE) == PWM_TB_Mode_Down) || \
|
||||
((VALUE) == PWM_TB_Mode_UpDown) || \
|
||||
((VALUE) == PWM_TB_Mode_Disable))
|
||||
|
||||
/**
|
||||
* @brief Событие для загрузки значения сравнения в теневом режиме
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_CMP_LoadEvent_CTREqZero = PWM_CMPCTL_LOADAMODE_CTREqZero, /*!< Загрузка отложенного значения при условии, что значение таймера равно нулю */
|
||||
PWM_CMP_LoadEvent_CTREqPeriod = PWM_CMPCTL_LOADAMODE_CTREqPRD, /*!< Загрузка отложенного значения при условии, что значение таймера равно периоду */
|
||||
PWM_CMP_LoadEvent_CTREqZeroOrPeriod = PWM_CMPCTL_LOADAMODE_CTREqZeroPRD, /*!< Загрузка отложенного значения при условии, что значение таймера равно нулю или периоду */
|
||||
PWM_CMP_LoadEvent_Disable = PWM_CMPCTL_LOADAMODE_Disable /*!< Загрузка отложенного значения запрещена */
|
||||
} PWM_CMP_LoadEvent_TypeDef;
|
||||
#define IS_PWM_CMP_LOAD_EVENT(VALUE) (((VALUE) == PWM_CMP_LoadEvent_CTREqZero) || \
|
||||
((VALUE) == PWM_CMP_LoadEvent_CTREqPeriod) || \
|
||||
((VALUE) == PWM_CMP_LoadEvent_CTREqZeroOrPeriod) || \
|
||||
((VALUE) == PWM_CMP_LoadEvent_Disable))
|
||||
|
||||
/**
|
||||
* @brief Выбор действия на выводе ШИМ
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_AQ_Action_None = PWM_AQCTLA_ZRO_NoAction, /*!< Нет реакции */
|
||||
PWM_AQ_Action_ToZero = PWM_AQCTLA_PRD_Clear, /*!< Переключение в ноль */
|
||||
PWM_AQ_Action_ToOne = PWM_AQCTLA_CAU_Set, /*!< Переключение в единицу */
|
||||
PWM_AQ_Action_Inv = PWM_AQCTLA_CAD_Toggle /*!< Инверсия текущего состояния */
|
||||
} PWM_AQ_Action_TypeDef;
|
||||
#define IS_PWM_AQ_ACTION(VALUE) (((VALUE) == PWM_AQ_Action_None) || \
|
||||
((VALUE) == PWM_AQ_Action_ToZero) || \
|
||||
((VALUE) == PWM_AQ_Action_ToOne) || \
|
||||
((VALUE) == PWM_AQ_Action_Inv))
|
||||
|
||||
/**
|
||||
* @brief Возможные события для генерации внешних сигналов/запросов
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_AQ_Event_CTREqZero = PWM_AQCTLA_ZRO_Pos, /*!< Значение таймера равно нулю */
|
||||
PWM_AQ_Event_CTREqPeriod = PWM_AQCTLA_PRD_Pos, /*!< Значение таймера равно периоду */
|
||||
PWM_AQ_Event_CTREqCMPAUp = PWM_AQCTLA_CAU_Pos, /*!< Значение таймера равно регистру CMPA при счете вверх */
|
||||
PWM_AQ_Event_CTREqCMPADown = PWM_AQCTLA_CAD_Pos, /*!< Значение таймера равно регистру CMPA при счете вниз */
|
||||
PWM_AQ_Event_CTREqCMPBUp = PWM_AQCTLA_CBU_Pos, /*!< Значение таймера равно регистру CMPB при счете вверх */
|
||||
PWM_AQ_Event_CTREqCMPBDown = PWM_AQCTLA_CBD_Pos /*!< Значение таймера равно регистру CMPB при счете вниз */
|
||||
} PWM_AQ_Event_TypeDef;
|
||||
#define IS_PWM_AQ_EVENT(VALUE) (((VALUE) == PWM_AQ_Event_CTREqZero) || \
|
||||
((VALUE) == PWM_AQ_Event_CTREqPeriod) || \
|
||||
((VALUE) == PWM_AQ_Event_CTREqCMPAUp) || \
|
||||
((VALUE) == PWM_AQ_Event_CTREqCMPADown) || \
|
||||
((VALUE) == PWM_AQ_Event_CTREqCMPBUp) || \
|
||||
((VALUE) == PWM_AQ_Event_CTREqCMPBDown))
|
||||
|
||||
/**
|
||||
* @brief Cобытия для применения настроек однократного или цилического программного воздействия на вывода
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_AQ_ForceShadowEvent_CTREqZero = PWM_AQSFRC_RLDCSF_CTREqZero, /*!< Значение таймера равно нулю */
|
||||
PWM_AQ_ForceShadowEvent_CTREqPeriod = PWM_AQSFRC_RLDCSF_CTREqPRD, /*!< Значение таймера равно периоду */
|
||||
PWM_AQ_ForceShadowEvent_CTREqPeriodZero = PWM_AQSFRC_RLDCSF_CTREqZeroPRD, /*!< Значение таймера равно периоду или нулю */
|
||||
PWM_AQ_ForceShadowEvent_None = PWM_AQSFRC_RLDCSF_NoShadow, /*!< Прямая запись */
|
||||
} PWM_AQ_ForceShadowEvent_TypeDef;
|
||||
#define IS_PWM_AQ_FORCE_SHADOW_EVENT(VALUE) (((VALUE) == PWM_AQ_ForceShadowEvent_CTREqZero) || \
|
||||
((VALUE) == PWM_AQ_ForceShadowEvent_CTREqPeriod) || \
|
||||
((VALUE) == PWM_AQ_ForceShadowEvent_CTREqPeriodZero) || \
|
||||
((VALUE) == PWM_AQ_ForceShadowEvent_None))
|
||||
|
||||
/**
|
||||
* @brief Выбор источников для формирования задержки
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_DB_In_A = PWM_DBCTL_INMODE_APosNeg, /*!< Входной сигнал А задержан по обоим фронтам */
|
||||
PWM_DB_In_AFallBRise = PWM_DBCTL_INMODE_ANeg_BPos, /*!< Входной сигнал A задержан заднему фронту, B - по переднему */
|
||||
PWM_DB_In_ARiseBFall = PWM_DBCTL_INMODE_APos_BNeg, /*!< Входной сигнал A задержан переднему фронту, B - по заднему */
|
||||
PWM_DB_In_B = PWM_DBCTL_INMODE_BPosNeg /*!< Входной сигнал B задержан по обоим фронтам */
|
||||
} PWM_DB_In_TypeDef;
|
||||
#define IS_PWM_DB_IN(VALUE) (((VALUE) == PWM_DB_In_A) || \
|
||||
((VALUE) == PWM_DB_In_ARiseBFall) || \
|
||||
((VALUE) == PWM_DB_In_AFallBRise) || \
|
||||
((VALUE) == PWM_DB_In_B))
|
||||
|
||||
/**
|
||||
* @brief Выбор полярности задержанных сигналов
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_DB_Polarity_ActiveHigh = PWM_DBCTL_POLSEL_InvDisable, /*!< Нет инверсии */
|
||||
PWM_DB_Polarity_ActiveLowCompl = PWM_DBCTL_POLSEL_InvA, /*!< Инвертируется сигнал, задержанный по переднему фронту */
|
||||
PWM_DB_Polarity_ActiveHighCompl = PWM_DBCTL_POLSEL_InvB, /*!< Инвертируется сигнал, задержанный по заднему фронту */
|
||||
PWM_DB_Polarity_ActiveLow = PWM_DBCTL_POLSEL_InvAB /*!< Инвертируются оба сигнала */
|
||||
} PWM_DB_Polarity_TypeDef;
|
||||
#define IS_PWM_DB_POLARITY(VALUE) (((VALUE) == PWM_DB_Polarity_ActiveHigh) || \
|
||||
((VALUE) == PWM_DB_Polarity_ActiveLowCompl) || \
|
||||
((VALUE) == PWM_DB_Polarity_ActiveHighCompl) || \
|
||||
((VALUE) == PWM_DB_Polarity_ActiveLow))
|
||||
|
||||
/**
|
||||
* @brief Выбор выходных сигналов блока задержки
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_DB_Out_BypassAB = PWM_DBCTL_OUTMODE_NoSpec, /*!< Нет задержки. Входные сигналы A и B подключены напрямую к выходу модуля задержки. */
|
||||
PWM_DB_Out_BypassA = PWM_DBCTL_OUTMODE_BNeg, /*!< Входной сигнал A подключен напрямую к выходу A модуля задержки. Задержанный по заднему фронту сигнал подключен к выходу B. */
|
||||
PWM_DB_Out_BypassB = PWM_DBCTL_OUTMODE_APos, /*!< Входной сигнал B подключен напрямую к выходу B модуля задержки. Задержанный по переднему фронту сигнал подключен к выходу A. */
|
||||
PWM_DB_Out_DelayAB = PWM_DBCTL_OUTMODE_Apos_BNeg /*!< Задержанный по переднему фронту сигнал подключен к выходу A, по заднему - к выходу B. */
|
||||
} PWM_DB_Out_TypeDef;
|
||||
#define IS_PWM_DB_OUT(VALUE) (((VALUE) == PWM_DB_Out_BypassAB) || \
|
||||
((VALUE) == PWM_DB_Out_BypassA) || \
|
||||
((VALUE) == PWM_DB_Out_BypassB) || \
|
||||
((VALUE) == PWM_DB_Out_DelayAB))
|
||||
|
||||
/**
|
||||
* @brief Возможные события для генерации внешних сигналов/запросов
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_ET_Event_CTREqZero = PWM_ETSEL_SOCASEL_CTREqZero, /*!< Значение таймера равно нулю */
|
||||
PWM_ET_Event_CTREqPeriod = PWM_ETSEL_SOCASEL_CTREqPRD, /*!< Значение таймера равно периоду */
|
||||
PWM_ET_Event_CTREqCMPA_Up = PWM_ETSEL_SOCASEL_CTREqCMPA_OnUp, /*!< Значение таймера равно регистру CMPA при счете вверх */
|
||||
PWM_ET_Event_CTREqCMPA_Down = PWM_ETSEL_SOCASEL_CTREqCMPA_OnDown, /*!< Значение таймера равно регистру CMPA при счете вниз */
|
||||
PWM_ET_Event_CTREqCMPB_Up = PWM_ETSEL_SOCASEL_CTREqCMPB_OnUp, /*!< Значение таймера равно регистру CMPB при счете вверх */
|
||||
PWM_ET_Event_CTREqCMPB_Down = PWM_ETSEL_SOCASEL_CTREqCMPB_OnDown /*!< Значение таймера равно регистру CMPB при счете вниз */
|
||||
} PWM_ET_Event_TypeDef;
|
||||
#define IS_PWM_ET_EVENT(VALUE) (((VALUE) == PWM_ET_Event_CTREqZero) || \
|
||||
((VALUE) == PWM_ET_Event_CTREqPeriod) || \
|
||||
((VALUE) == PWM_ET_Event_CTREqCMPA_Up) || \
|
||||
((VALUE) == PWM_ET_Event_CTREqCMPA_Down) || \
|
||||
((VALUE) == PWM_ET_Event_CTREqCMPB_Up) || \
|
||||
((VALUE) == PWM_ET_Event_CTREqCMPB_Down))
|
||||
|
||||
/**
|
||||
* @brief Выбор поведения вывода в случае наступления сигнала аварии
|
||||
*/
|
||||
typedef enum {
|
||||
PWM_TZ_Action_ToZ = PWM_TZCTL_TZA_Z, /*!< Переключение вывода в третье состояние */
|
||||
PWM_TZ_Action_ToOne = PWM_TZCTL_TZA_Set, /*!< Переключение в единицу */
|
||||
PWM_TZ_Action_ToZero = PWM_TZCTL_TZA_Clear, /*!< Переключение в ноль */
|
||||
PWM_TZ_Action_None = PWM_TZCTL_TZA_NoAction /*!< Нет действий */
|
||||
} PWM_TZ_Action_TypeDef;
|
||||
#define IS_PWM_TZ_ACTION(VALUE) (((VALUE) == PWM_TZ_Action_ToZ) || \
|
||||
((VALUE) == PWM_TZ_Action_ToOne) || \
|
||||
((VALUE) == PWM_TZ_Action_ToZero) || \
|
||||
((VALUE) == PWM_TZ_Action_None))
|
||||
|
||||
/**
|
||||
* @brief Выбор поведения вывода в случае наступления события удержания.
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
PWM_HD_Action_ToOne = PWM_HDCTL_HDA_Set, /*!< Переключение в единицу*/
|
||||
PWM_HD_Action_ToZero = PWM_HDCTL_HDA_Clear, /*!< Переключение в ноль */
|
||||
PWM_HD_Action_None = PWM_HDCTL_HDA_NoAction /*!< Нет действий */
|
||||
} PWM_HD_Action_TypeDef;
|
||||
#define IS_PWM_HD_ACTION(VALUE) (((VALUE) == PWM_HD_Action_ToOne) || \
|
||||
((VALUE) == PWM_HD_Action_ToZero) || \
|
||||
((VALUE) == PWM_HD_Action_None))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации таймера-счетчика блока ШИМ
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
PWM_TB_Halt_TypeDef Halt; /*!< Выбор режима остановки таймера при отладке */
|
||||
PWM_TB_ClkDiv_TypeDef ClkDiv; /*!< Коэффициент базового деления частоты */
|
||||
PWM_TB_ClkDivExtra_TypeDef ClkDivExtra; /*!< Коэффициент дополнительного деления частоты.
|
||||
Результирующий коэффциент = ClkDiv * ClkDivExtra */
|
||||
PWM_TB_SyncOut_TypeDef SyncOut; /*!< Источник для выходного сигнала синхронизации SYNCO */
|
||||
FunctionalState PhaseSync; /*!< Разрешает загрузку счетчика значением регистра фазы при получении события синхронизации */
|
||||
PWM_TB_Dir_TypeDef PhaseSyncDir; /*!< Задание направления счета после синхронизации фазы */
|
||||
uint32_t Phase; /*!< Значение фазы ШИМ при получении события синхронизации.
|
||||
Параметр может принимать любое значение из диапазона: 0x0000-0xFFFF. */
|
||||
PWM_TB_Mode_TypeDef Mode; /*!< Задание направления счета */
|
||||
FunctionalState PeriodDirectLoad; /*!< Разрешает только прямую загрузку в регистр периода (теневая отключена) */
|
||||
uint32_t Period; /*!< Значение периода таймера ШИМ.
|
||||
Параметр может принимать любое значение из диапазона: 0x0000-0xFFFF. */
|
||||
} PWM_TB_Init_TypeDef;
|
||||
#define IS_PWM_TB_PHASE_VAL(VALUE) ((VALUE) < 0x10000)
|
||||
#define IS_PWM_TB_PERIOD_VAL(VALUE) ((VALUE) < 0x10000)
|
||||
#define IS_PWM_TB_COUNTER_VAL(VALUE) ((VALUE) < 0x10000)
|
||||
|
||||
typedef struct
|
||||
{
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqZero; /*!< Действие в канале А, при наступлении события равенства счетчика таймера нулю */
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqPeriod; /*!< Действие в канале А, при наступлении события равенства счетчика значению периода */
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqCMPAUp; /*!< Действие в канале А, при наступлении события равенства счетчика таймера значению сравнения A при счете вверх */
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqCMPADown; /*!< Действие в канале A, при наступлении события равенства счетчика таймера значению сравнения A при счете вниз */
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqCMPBUp; /*!< Действие в канале А, при наступлении события равенства счетчика таймера значению сравнения B при счете вверх */
|
||||
PWM_AQ_Action_TypeDef ActionA_CTREqCMPBDown; /*!< Действие в канале A, при наступлении события равенства счетчика таймера значению сравнения B при счете вниз */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqZero; /*!< Действие в канале B, при наступлении события равенства счетчика таймера нулю */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqPeriod; /*!< Действие в канале B, при наступлении события равенства счетчика значению периода */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqCMPAUp; /*!< Действие в канале B, при наступлении события равенства счетчика таймера значению сравнения A при счете вверх */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqCMPADown; /*!< Действие в канале B, при наступлении события равенства счетчика таймера значению сравнения A при счете вниз */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqCMPBUp; /*!< Действие в канале B, при наступлении события равенства счетчика таймера значению сравнения B при счете вверх */
|
||||
PWM_AQ_Action_TypeDef ActionB_CTREqCMPBDown; /*!< Действие в канале B, при наступлении события равенства счетчика таймера значению сравнения B при счете вниз */
|
||||
} PWM_AQ_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации компараторов блока ШИМ
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState CmpADirectLoad; /*!< Разрешает только прямую загрузку в регистр CMPA (теневая отключена) */
|
||||
PWM_CMP_LoadEvent_TypeDef LoadEventCmpA; /*!< Событие для теневой загрузки в регистр сравнения CMPA */
|
||||
uint32_t CmpA; /*!< Значение порога срабатывания канала А, которое сравнивается со значением счетчика таймера.
|
||||
Параметр может принимать любое значение из диапазона: 0x0000-0xFFFF. */
|
||||
FunctionalState CmpBDirectLoad; /*!< Разрешает только прямую загрузку в регистр CMPB (теневая отключена) */
|
||||
PWM_CMP_LoadEvent_TypeDef LoadEventCmpB; /*!< Событие для теневой загрузки в регистр сравнения CMPB */
|
||||
uint32_t CmpB; /*!< Значение порога срабатывания канала B, которое сравнивается со значением счетчика таймера.
|
||||
Параметр может принимать любое значение из диапазона: 0x0000-0xFFFF. */
|
||||
} PWM_CMP_Init_TypeDef;
|
||||
#define IS_PWM_CMP_VAL(VALUE) ((VALUE) < 0x10000)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации порогового выключателя блока ШИМ
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
PWM_HD_Action_TypeDef ActionA; /*!< Настройка поведения канала A при поступлении события удержания */
|
||||
PWM_HD_Action_TypeDef ActionB; /*!< Настройка поведения канала B при поступлении события удержания */
|
||||
uint32_t Source; /*!< Выбор источников для генерации события удержания.
|
||||
Параметр принимает любую совокупность значений из @ref PWM_HD_Source_Define */
|
||||
FunctionalState Cycle; /*!< Включение циклической обработки сигнала удержания */
|
||||
FunctionalState OneShot; /*!< Включение однократной обработки сигнала удержания */
|
||||
} PWM_HD_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации задержки сигналов ШИМ ("мертвое время").
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
PWM_DB_In_TypeDef In; /*!< Выбор источников для формирования задержки */
|
||||
PWM_DB_Polarity_TypeDef Polarity; /*!< Выбор полярности задержанных сигналов */
|
||||
PWM_DB_Out_TypeDef Out; /*!< Выбор выходных сигналов блока задержки */
|
||||
uint32_t RiseDelay; /*!< Величина задержки переднего фронта.
|
||||
Параметр может принимать любое значение из диапазона: 0x000-0x3FF. */
|
||||
uint32_t FallDelay; /*!< Величина задержки заднего фронта.
|
||||
Параметр может принимать любое значение из диапазона: 0x000-0x3FF. */
|
||||
} PWM_DB_Init_TypeDef;
|
||||
#define IS_PWM_DB_DELAY_VAL(VALUE) ((VALUE) < 0x400)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации обработчика сигнала аварии блока ШИМ
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
PWM_TZ_Action_TypeDef ActionA; /*!< Настройка поведения канала A при поступлении сигнала аварии */
|
||||
PWM_TZ_Action_TypeDef ActionB; /*!< Настройка поведения канала B при поступлении сигнала аварии */
|
||||
FunctionalState Cycle; /*!< Включение циклической обработки сигнала аварии */
|
||||
FunctionalState OneShot; /*!< Включение однократной обработки сигнала аварии */
|
||||
} PWM_TZ_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации блока "триггера событий" для генерации внешних сигналов/запросов
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState SOCA; /*!< Канал А: разрешает формирование строба запуска АЦП */
|
||||
PWM_ET_Event_TypeDef EventSOCA; /*!< Канал А: выбор события для формирования строба запуска АЦП */
|
||||
uint32_t PeriodSOCA; /*!< Канал А: выбор количества событий для возникновения строба АЦП.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д. */
|
||||
FunctionalState SOCB; /*!< Канал B: разрешает формирование строба запуска АЦП */
|
||||
PWM_ET_Event_TypeDef EventSOCB; /*!< Канал B: выбор события для формирования строба запуска АЦП */
|
||||
uint32_t PeriodSOCB; /*!< Канал B: выбор количества событий для возникновения строба запуска АЦП.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д. */
|
||||
FunctionalState DRQA; /*!< Канал А: разрешает формирование запроса DMA */
|
||||
PWM_ET_Event_TypeDef EventDRQA; /*!< Канал А: выбор события для формирования запроса DMA */
|
||||
uint32_t PeriodDRQA; /*!< Канал А: выбор количества событий для возникновения запроса DMA.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д. */
|
||||
FunctionalState DRQB; /*!< Канал B: разрешает формирование запроса DMA */
|
||||
PWM_ET_Event_TypeDef EventDRQB; /*!< Канал B: выбор события для формирования запроса DMA */
|
||||
uint32_t PeriodDRQB; /*!< Канал B: выбор количества событий для возникновения запроса DMA.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д. */
|
||||
} PWM_ET_Init_TypeDef;
|
||||
#define IS_PWM_ET_PERIOD(VALUE) ((VALUE) < 0x4)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_DeInit(PWM_TypeDef* PWMx);
|
||||
|
||||
/**
|
||||
* @brief Установка ширины фильтрации коротких импульсов
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param FilterVal Значение.
|
||||
* Параметр принимает любое значение из диапазона 0x00-0xFF,
|
||||
* где 0 - фильтр выключен, а 0xFF - 25.6 мкс (шаг установки 0.1 мкс).
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_FilterConfig(PWM_TypeDef* PWMx, uint32_t FilterVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_FILTER(FilterVal));
|
||||
|
||||
WRITE_REG(PWMx->FWDTH, FilterVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение всех теневых загрузок регистров PWM
|
||||
* @param PWMx Выбор блока PWM, где x лежит в диапазоне 0-2.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_GlobalShadowLoadCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.SHDWGLOB, State);
|
||||
}
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_TimeBase Счетчик
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_TB_Init(PWM_TypeDef* PWMx, PWM_TB_Init_TypeDef* InitStruct);
|
||||
void PWM_TB_StructInit(PWM_TB_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Управление предделителями тактирования таймеров блоков PWM
|
||||
* @param Presc Выбор предделителей блоков.
|
||||
* Параметр принимает любою совокупность значений из @ref PWM_Presc_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_PrescCmd(uint32_t Presc, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_TB_PRESC(Presc));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(SIU->PWMSYNC, Presc, State ? Presc : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка коэффициента деления частоты для получения счетного тактового сигнала TBCLK.
|
||||
* Результирующий коэффциент = ClkDiv * ClkDivExtra
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ClkDiv Выбор делителя
|
||||
* @param ClkDivExtra Выбор делителя
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_ClkDivConfig(PWM_TypeDef* PWMx, PWM_TB_ClkDiv_TypeDef ClkDiv, PWM_TB_ClkDivExtra_TypeDef ClkDivExtra)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_CLK_DIV(ClkDiv));
|
||||
assert_param(IS_PWM_TB_CLK_DIV_EXTRA(ClkDivExtra));
|
||||
|
||||
MODIFY_REG(PWMx->TBCTL, PWM_TBCTL_CLKDIV_Msk | PWM_TBCTL_HSPCLKDIV_Msk,
|
||||
((ClkDiv << PWM_TBCTL_CLKDIV_Pos) |
|
||||
(ClkDivExtra << PWM_TBCTL_HSPCLKDIV_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага состояния таймера PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любою совокупность значений из @ref PWM_TB_Status_Define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_TB_Status(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_STATUS(Status));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->TBSTS, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов статусов таймера PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любою совокупность значений из @ref PWM_TB_Status_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_StatusClear(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_STATUS(Status));
|
||||
|
||||
WRITE_REG(PWMx->TBSTS, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param CounterVal Значение счетчика
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_SetCounter(PWM_TypeDef* PWMx, uint32_t CounterVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_COUNTER_VAL(CounterVal));
|
||||
|
||||
WRITE_REG(PWMx->TBCTR, CounterVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Значение периода
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_SetPeriod(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_PERIOD_VAL(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->TBPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения фазы PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PhaseVal Значение фазы
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_SetPhase(PWM_TypeDef* PWMx, uint32_t PhaseVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_PHASE_VAL(PhaseVal));
|
||||
|
||||
WRITE_REG(PWMx->TBPHS, PhaseVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение счетчика
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_TB_GetCounter(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->TBCTR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения периода PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение периода
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_TB_GetPeriod(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->TBPRD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения фазы PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение фазы
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_TB_GetPhase(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->TBPHS);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный запуск входного синхроимпульса SYNCI
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_SwSyncInCmd(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.SWFSYNC, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима остановки таймера PWM при отладке
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Halt Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_HaltConfig(PWM_TypeDef* PWMx, PWM_TB_Halt_TypeDef Halt)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_HALT(Halt));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.FREESOFT, Halt);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка источника выходного сигнала синхронизации SYNCO
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param SyncOut Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_SyncOutConfig(PWM_TypeDef* PWMx, PWM_TB_SyncOut_TypeDef SyncOut)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_SYNC_OUT(SyncOut));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.SYNCOSEL, SyncOut);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешает загрузку счетчика значением регистра фазы при получении события синхронизации
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_PhaseSyncCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.PHSEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание направления счета после синхронизации фазы
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PhaseSyncDir Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_PhaseSyncDirConfig(PWM_TypeDef* PWMx, PWM_TB_Dir_TypeDef PhaseSyncDir)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_DIR(PhaseSyncDir));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.PHSDIR, PhaseSyncDir);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание направления счета PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_ModeConfig(PWM_TypeDef* PWMx, PWM_TB_Mode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TB_MODE(Mode));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.CTRMODE, Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешает прямую загрузку в регистр периода (теневая отключена)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TB_PeriodDirectLoadCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->TBCTL_bit.PRDLD, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_ActionQualifier Управление поведением выводов
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_AQ_Init(PWM_TypeDef* PWMx, PWM_AQ_Init_TypeDef* InitStruct);
|
||||
void PWM_AQ_StructInit(PWM_AQ_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Задание действия на выходе PWM A по выбранному событию
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ActionAConfig(PWM_TypeDef* PWMx, PWM_AQ_Event_TypeDef Event, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_EVENT(Event));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
MODIFY_REG(PWMx->AQCTLA, 3 << (uint32_t)Event, Action << (uint32_t)Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программное задание продолжительного воздействия на канал PWM A
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceContACmd(PWM_TypeDef* PWMx, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->AQCSFRC_bit.CSFA, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка типа однократного программного воздействия на канал PWM A
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceAConfig(PWM_TypeDef* PWMx, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->AQSFRC_bit.ACTSFA, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Применение выбранного однократного программного воздействия на канал PWM A
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceACmd(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->AQSFRC_bit.OTSFA, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание действия на выходе PWM B по выбранному событию
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ActionBConfig(PWM_TypeDef* PWMx, PWM_AQ_Event_TypeDef Event, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_EVENT(Event));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
MODIFY_REG(PWMx->AQCTLB, 3 << (uint32_t)Event, Action << (uint32_t)Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программное задание продолжительного воздействия на канал PWM B
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceContBCmd(PWM_TypeDef* PWMx, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->AQCSFRC_bit.CSFB, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка типа однократного программного воздействия на канал PWM B
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceBConfig(PWM_TypeDef* PWMx, PWM_AQ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->AQSFRC_bit.ACTSFB, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Применение выбранного однократного программного воздействия на канал PWM B
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceBCmd(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->AQSFRC_bit.OTSFB, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задание события для применения настроек однократного или цилического программного воздействия на вывода
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_AQ_ForceShadowConfig(PWM_TypeDef* PWMx, PWM_AQ_ForceShadowEvent_TypeDef ForceShadowEvent)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_AQ_FORCE_SHADOW_EVENT(ForceShadowEvent));
|
||||
|
||||
WRITE_REG(PWMx->AQSFRC_bit.RLDCSF, (uint32_t)ForceShadowEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_Compare Компараторы
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_CMP_Init(PWM_TypeDef* PWMx, PWM_CMP_Init_TypeDef* InitStruct);
|
||||
void PWM_CMP_StructInit(PWM_CMP_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Настройка cобытия для теневой загрузки в регистр сравнения CMPA
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param LoadEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_CmpALoadEventConfig(PWM_TypeDef* PWMx, PWM_CMP_LoadEvent_TypeDef LoadEvent)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_CMP_LOAD_EVENT(LoadEvent));
|
||||
|
||||
WRITE_REG(PWMx->CMPCTL_bit.LOADAMODE, LoadEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешает прямую загрузку в регистр CMPA (теневая отключена)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_CmpADirectLoadCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->CMPCTL_bit.SHDWAMODE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения сравнения A PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param CMPAVal Значение сравнения
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_SetCmpA(PWM_TypeDef* PWMx, uint32_t CMPAVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_CMP_VAL(CMPAVal));
|
||||
|
||||
WRITE_REG(PWMx->CMPA_bit.CMPA, CMPAVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения сравнения A PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение сравнения
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_CMP_GetCmpA(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->CMPA_bit.CMPA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка cобытия для теневой загрузки в регистр сравнения CMPB
|
||||
* @param PWMx Выбор ШИМ, где x лежит в диапазоне 0-2
|
||||
* @param LoadEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_CmpBLoadEventConfig(PWM_TypeDef* PWMx, PWM_CMP_LoadEvent_TypeDef LoadEvent)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_CMP_LOAD_EVENT(LoadEvent));
|
||||
|
||||
WRITE_REG(PWMx->CMPCTL_bit.LOADBMODE, LoadEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешает прямую загрузку в регистр CMPB (теневая отключена)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_CmpBDirectLoadCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->CMPCTL_bit.SHDWBMODE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения сравнения B PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param CMPBVal Значение сравнения
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_CMP_SetCmpB(PWM_TypeDef* PWMx, uint32_t CMPBVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_CMP_VAL(CMPBVal));
|
||||
|
||||
WRITE_REG(PWMx->CMPB_bit.CMPB, CMPBVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения сравнения B PWM
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение сравнения
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_CMP_GetCmpB(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->CMPB_bit.CMPB);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага состояния компараторов PWM.
|
||||
* Флаги установлены, если произошла запись в активный регистр значения сравнения из теневого.
|
||||
* Сбрасываются флаги автоматически при каждой записи в теневой регистр.
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любою совокупность значений из @ref PWM_CMP_Status_Define.
|
||||
* @retval Status Статус флагов. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_CMP_Status(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_CMP_STATUS(Status));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->CMPCTL, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_HoldDetector Блок порогового выключателя
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_HD_Init(PWM_TypeDef* PWMx, PWM_HD_Init_TypeDef* InitStruct);
|
||||
void PWM_HD_StructInit(PWM_HD_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Настройка поведения канала A при поступлении события удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ActionAConfig(PWM_TypeDef* PWMx, PWM_HD_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->HDCTL_bit.HDA, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка поведения канала B при поступлении события удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ActionBConfig(PWM_TypeDef* PWMx, PWM_HD_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->HDCTL_bit.HDB, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор источников для генерации события удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Source Выбор источника
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_HD_Source_Define
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_SourceCmd(PWM_TypeDef* PWMx, uint32_t Source, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_SOURCE(Source));
|
||||
|
||||
MODIFY_REG(PWMx->HDSEL, Source, State ? Source : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение циклической обработки сигнала удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_CycleCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->HDSEL_bit.CBC, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение однократной обработки сигнала удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_OneShotCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->HDSEL_bit.OST, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение прерывания по событию удержания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источника прерывания
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_HD_ITSource_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ITCmd(PWM_TypeDef* PWMx, uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_IT_SOURCE(ITSource));
|
||||
|
||||
MODIFY_REG(PWMx->HDEINT, ITSource, State ? ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный вызов прерывания от обработчика событий удержания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источника прерывания
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_HD_ITSource_Define
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ITForceCmd(PWM_TypeDef* PWMx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(PWMx->HDFRC, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага прерывания от обработчика событий удержания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_HD_ITSource_Define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_HD_ITStatus(PWM_TypeDef* PWMx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_IT_STATUS(ITStatus));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->HDFLG, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага прерывания от обработчика событий удержания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_HD_ITSource_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ITStatusClear(PWM_TypeDef* PWMx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_HD_IT_STATUS(ITStatus));
|
||||
|
||||
WRITE_REG(PWMx->HDCLR, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса активного запроса прерывания от обработчика событий удержания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Status Статус запроса прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_HD_ITPendStatus(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->HDINTCLR, PWM_HDINTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс активного запроса прерывания от обработчика событий удержания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Нет
|
||||
*/
|
||||
__STATIC_INLINE void PWM_HD_ITPendStatusClear(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->HDINTCLR_bit.INT, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_DeadBand Блок "мертвого времени"
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_DB_Init(PWM_TypeDef* PWMx, PWM_DB_Init_TypeDef* InitStruct);
|
||||
void PWM_DB_StructInit(PWM_DB_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Выбор источников для формирования задержки
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param In Выбор источника
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_DB_InConfig(PWM_TypeDef* PWMx, PWM_DB_In_TypeDef In)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_DB_IN(In));
|
||||
|
||||
WRITE_REG(PWMx->DBCTL_bit.INMODE, In);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор выходных сигналов блока задержки
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Out Выбор сигнала
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_DB_OutConfig(PWM_TypeDef* PWMx, PWM_DB_Out_TypeDef Out)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_DB_OUT(Out));
|
||||
|
||||
WRITE_REG(PWMx->DBCTL_bit.OUTMODE, Out);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор полярности задержанных сигналов
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Polarity Выбор полярности
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_DB_PolarityConfig(PWM_TypeDef* PWMx, PWM_DB_Polarity_TypeDef Polarity)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_DB_POLARITY(Polarity));
|
||||
|
||||
WRITE_REG(PWMx->DBCTL_bit.POLSEL, Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения величины задержки по переднему фронту
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param RiseDelayVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_DB_SetRiseDelay(PWM_TypeDef* PWMx, uint32_t RiseDelayVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_DB_DELAY_VAL(RiseDelayVal));
|
||||
|
||||
WRITE_REG(PWMx->DBRED, RiseDelayVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения величины задержки по заднему фронту
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param FallDelayVal Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_DB_SetFallDelay(PWM_TypeDef* PWMx, uint32_t FallDelayVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_DB_DELAY_VAL(FallDelayVal));
|
||||
|
||||
WRITE_REG(PWMx->DBFED, FallDelayVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения величины задержки по переднему фронту
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_DB_GetRiseDelay(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->DBRED);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения величины задержки по заднему фронту
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_DB_GetFallDelay(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->DBFED);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_PWM_Chopper Блок модуляции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка модулятора сигналов ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param DutyVal Значение скважности второго и последующего импульсов.
|
||||
* Параметр принимает любое значение из диапазона 0x0-0x6,
|
||||
* где 0x0 - скважность 1/8, а 0x6 - 7/8.
|
||||
* @param FreqDivVal Значение делителя частоты второго и последующего импульсов.
|
||||
* Параметр принимает любое значение из диапазона 0x0-0x7,
|
||||
* где 0x0 - без деления, 0x1 - с коэф. 1/2, а 0x7 - 1/8.
|
||||
* @param FirstWidthVal Значение ширины первого импульса в тактах SysClk/8.
|
||||
* Параметр принимает любое значение из диапазона 0x0-0xF,
|
||||
* где 0x0 - 1 такт, а 0xF - 16 тактов.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_PC_Config(PWM_TypeDef* PWMx, uint32_t DutyVal, uint32_t FreqDivVal, uint32_t FirstWidthVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_PC_DUTY(DutyVal));
|
||||
assert_param(IS_PWM_PC_FREQ_DIV(FreqDivVal));
|
||||
assert_param(IS_PWM_PC_FIRST_WIDTH(FirstWidthVal));
|
||||
|
||||
MODIFY_REG(PWMx->PCCTL, PWM_PCCTL_CHPDUTY_Msk | PWM_PCCTL_CHPFREQ_Msk | PWM_PCCTL_OSTWTH_Msk,
|
||||
((DutyVal << PWM_PCCTL_CHPDUTY_Pos) |
|
||||
(FreqDivVal << PWM_PCCTL_CHPFREQ_Pos) |
|
||||
(FirstWidthVal << PWM_PCCTL_OSTWTH_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение модулятора блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_PC_Cmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->PCCTL_bit.CHPEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_TripZone Блок обработки сигналов аварии
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_TZ_Init(PWM_TypeDef* PWMx, PWM_TZ_Init_TypeDef* InitStruct);
|
||||
void PWM_TZ_StructInit(PWM_TZ_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Настройка поведения канала A при поступлении сигнала аварии
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ActionAConfig(PWM_TypeDef* PWMx, PWM_TZ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->TZCTL_bit.TZA, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка поведения канала B при поступлении сигнала аварии
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Action Выбор действия
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ActionBConfig(PWM_TypeDef* PWMx, PWM_TZ_Action_TypeDef Action)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_ACTION(Action));
|
||||
|
||||
WRITE_REG(PWMx->TZCTL_bit.TZB, Action);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение циклической обработки сигнала аварии
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_CycleCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->TZSEL_bit.CBC, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение однократной обработки сигнала аварии
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_OneShotCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->TZSEL_bit.OST, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение прерывания по сигналу аварии
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источника прерывания
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_TZ_ITSource_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ITCmd(PWM_TypeDef* PWMx, uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_IT_SOURCE(ITSource));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(PWMx->TZEINT, ITSource, State ? ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага прерывания от обработчика сигналов аварии выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_TZ_ITSource_Define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_TZ_ITStatus(PWM_TypeDef* PWMx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_IT_STATUS(ITStatus));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->TZFLG, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флага прерывания от обработчика сигналов аварии выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITStatus Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_TZ_ITSource_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ITStatusClear(PWM_TypeDef* PWMx, uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_IT_STATUS(ITStatus));
|
||||
|
||||
WRITE_REG(PWMx->TZCLR, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса активного запроса прерывания от обработчика сигналов аварии выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Status Статус запроса прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_TZ_ITPendStatus(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->TZINTCLR, PWM_TZINTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс активного запроса прерывания от обработчика сигналов аварии выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Нет
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ITPendStatusClear(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->TZINTCLR_bit.INT, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный вызов прерывания от обработчика сигналов аварии выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param ITSource Выбор источника прерывания
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_TZ_ITSource_Define
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_TZ_ITForceCmd(PWM_TypeDef* PWMx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_TZ_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(PWMx->TZFRC, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_EventTrigger Генерация внешних сигналов
|
||||
* @{
|
||||
*/
|
||||
|
||||
void PWM_ET_Init(PWM_TypeDef* PWMx, PWM_ET_Init_TypeDef* InitStruct);
|
||||
void PWM_ET_StructInit(PWM_ET_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Включение генерации строба запуска АЦП по событию канала A
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCACmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.SOCAEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события канала A для генерации строба запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCAEventConfig(PWM_TypeDef* PWMx, PWM_ET_Event_TypeDef Event)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_EVENT(Event));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.SOCASEL, Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества событий канала A для генерации строба запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Выбор количества событий для возникновения строба АЦП.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCAPeriodConfig(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_PERIOD(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->ETPS_bit.SOCAPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика событий, приводящих к генерации события запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_ET_GetEventCountSOCA(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->ETPS_bit.SOCACNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации строба запуска АЦП по событию канала B
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCBCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.SOCBEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события канала B для генерации строба запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCBEventConfig(PWM_TypeDef* PWMx, PWM_ET_Event_TypeDef Event)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_EVENT(Event));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.SOCBSEL, Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества событий канала B для генерации строба запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Выбор количества событий для возникновения строба АЦП.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_SOCBPeriodConfig(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_PERIOD(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->ETPS_bit.SOCBPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика событий, приводящих к генерации события запуска АЦП
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_ET_GetEventCountSOCB(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->ETPS_bit.SOCBCNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации запроса DMA по событию канала A
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQACmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.DRQAEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события канала A для генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQAEventConfig(PWM_TypeDef* PWMx, PWM_ET_Event_TypeDef Event)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_EVENT(Event));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.DRQASEL, Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества событий канала A для генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Выбор количества событий для возникновения запроса DMA.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQAPeriodConfig(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_PERIOD(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->ETPS_bit.DRQAPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика событий, приводящих к генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_ET_GetEventCountDRQA(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->ETPS_bit.DRQACNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации запроса DMA по событию канала B
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQBCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.DRQBEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события канала B для генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQBEventConfig(PWM_TypeDef* PWMx, PWM_ET_Event_TypeDef Event)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_EVENT(Event));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.DRQBSEL, Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества событий канала B для генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Выбор количества событий для возникновения запроса DMA.
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_DRQBPeriodConfig(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_PERIOD(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->ETPS_bit.DRQBPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика событий, приводящих к генерации запроса DMA
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_ET_GetEventCountDRQB(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->ETPS_bit.DRQBCNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статусов флагов генерации внешних сигналов/запросов выбранным блоком ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_ET_Status_Define.
|
||||
* @retval Status Статус. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_ET_Status(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_STATUS(Status));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->ETFLG, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов генерации внешних сигналов/запросов выбранным блоком ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_ET_Status_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_StatusClear(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_STATUS(Status));
|
||||
|
||||
WRITE_REG(PWMx->ETCLR, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный вызов генерации внешних сигналов/запросов выбранным блоком ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Status Выбор источника.
|
||||
* Параметр принимает любую совокупность значений из @ref PWM_ET_Status_Define
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ET_ForceCmd(PWM_TypeDef* PWMx, uint32_t Status)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_STATUS(Status));
|
||||
|
||||
WRITE_REG(PWMx->ETFRC, Status);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Exported_Functions_IT Прерывание счетчика ШИМ
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка события канала для генерации прерывания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param Event Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITEventConfig(PWM_TypeDef* PWMx, PWM_ET_Event_TypeDef Event)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_EVENT(Event));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.INTSEL, Event);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества событий для генерации прерывания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param PeriodVal Выбор количества событий для возникновения прерывания
|
||||
Параметр принимает любое значение из диапазона 0-3,
|
||||
где 0 - соответсвует каждому событию, 1 - каждому второму и т.д.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITPeriodConfig(PWM_TypeDef* PWMx, uint32_t PeriodVal)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_PWM_ET_PERIOD(PeriodVal));
|
||||
|
||||
WRITE_REG(PWMx->ETPS_bit.INTPRD, PeriodVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации прерывания ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITCmd(PWM_TypeDef* PWMx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(PWMx->ETSEL_bit.INTEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика событий, приводящих к генерации прерывания
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t PWM_GetITEventCount(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return READ_REG(PWMx->ETPS_bit.INTCNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага прерывания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_ITStatus(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->ETFLG, PWM_ETFRC_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов прерывания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITStatusClear(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->ETCLR, PWM_ETCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса флага активного прерывания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Status Статус
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus PWM_ITPendStatus(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
return (FlagStatus)READ_BIT(PWMx->INTCLR, PWM_INTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов активного прерывания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITPendStatusClear(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->INTCLR, PWM_INTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный вызов прерывания выбранного блока ШИМ
|
||||
* @param PWMx Выбор PWM, где x лежит в диапазоне 0-2
|
||||
* @retval Нет
|
||||
*/
|
||||
__STATIC_INLINE void PWM_ITForceCmd(PWM_TypeDef* PWMx)
|
||||
{
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
WRITE_REG(PWMx->ETFRC, PWM_ETFRC_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_PWM_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
1246
MDK-ARM/platform/plib035/inc/plib035_qep.h
Normal file
1246
MDK-ARM/platform/plib035/inc/plib035_qep.h
Normal file
@@ -0,0 +1,1246 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_qep.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* QEP, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_QEP_H
|
||||
#define __PLIB035_QEP_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup QEP
|
||||
* @brief Драйвер для работы с QEP
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Flag_Define Флаги работы QEP
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define QEP_Flag_PCError QEP_QEPSTS_PCEF_Msk /*!< Флаг ошибки счетчика позиции. Обновляется по каждому сигналу индексации. */
|
||||
#define QEP_Flag_FirstIndex QEP_QEPSTS_FIMF_Msk /*!< Флаг приема первого импульса сигнала индексации */
|
||||
#define QEP_Flag_CAPDirectionError QEP_QEPSTS_CDEF_Msk /*!< Флаг ошибки изменения направления вращения вала ротора между двумя событиями захвата */
|
||||
#define QEP_Flag_CAPCountOverflow QEP_QEPSTS_COEF_Msk /*!< Флаг переполнения счетчика модуля захвата */
|
||||
#define QEP_Flag_QuadDirectionI QEP_QEPSTS_QDLF_Msk /*!< Флаг направления вращения. Обновляется по каждому сигналу индексации. */
|
||||
#define QEP_Flag_QuadDirection QEP_QEPSTS_QDF_Msk /*!< Флаг направления вращения. Обновляется по каждому событию на входах квадратур. */
|
||||
#define QEP_Flag_FirstIndexDirection QEP_QEPSTS_FIDF_Msk /*!< Индикатор направления вращения по событию первого импульса индексации. */
|
||||
#define QEP_Flag_CAPEvent QEP_QEPSTS_UPEVNT_Msk /*!< Флаг события захвата */
|
||||
#define QEP_Flag_DirectionChange QEP_QEPSTS_DCF_Msk /*!< Флаг изменения направления вращения вала ротора */
|
||||
#define QEP_Flag_All (QEP_Flag_PCError | \
|
||||
QEP_Flag_FirstIndex | \
|
||||
QEP_Flag_CAPDirectionError | \
|
||||
QEP_Flag_CAPCountOverflow | \
|
||||
QEP_Flag_QuadDirectionI | \
|
||||
QEP_Flag_QuadDirection | \
|
||||
QEP_Flag_FirstIndexDirection | \
|
||||
QEP_Flag_CAPEvent | \
|
||||
QEP_Flag_DirectionChange) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_QEP_FLAG(VALUE) (((VALUE) & ~QEP_Flag_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_ITStatus_Define Флаги прерываний
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define QEP_ITStatus_GeneralInt QEP_QFLG_INT_Msk /*!< Флаг общего сигнала прерывания */
|
||||
#define QEP_ITStatus_PCError QEP_QFLG_PCE_Msk /*!< Флаг прерывания по ошибке счетчика позиции */
|
||||
#define QEP_ITStatus_QuadPhaseError QEP_QFLG_QPE_Msk /*!< Флаг прерывания по ошибке фазы на квадратурном входе */
|
||||
#define QEP_ITStatus_DirectionChange QEP_QFLG_QDC_Msk /*!< Флаг прерывания по смене направления вращения */
|
||||
#define QEP_ITStatus_Watchdog QEP_QFLG_WTO_Msk /*!< Флаг прерывания по срабатыванию сторожевого таймера */
|
||||
#define QEP_ITStatus_PCOverflow QEP_QFLG_PCO_Msk /*!< Флаг прерывания по переполнению счетчика позиции (переход через максимальное значение) */
|
||||
#define QEP_ITStatus_PCUnderflow QEP_QFLG_PCU_Msk /*!< Флаг прерывания по недозаполнению счетчика позиции (переход через минимальное значение) */
|
||||
#define QEP_ITStatus_CMPShadowReady QEP_QFLG_PCR_Msk /*!< Флаг прерывания по готовности компаратора к загрузке значения сравнения из отложенного регистра */
|
||||
#define QEP_ITStatus_CMP QEP_QFLG_PCM_Msk /*!< Флаг прерывания по срабатыванию компаратора */
|
||||
#define QEP_ITStatus_Strobe QEP_QFLG_SEL_Msk /*!< Флаг прерывания по событию стробирования */
|
||||
#define QEP_ITStatus_Index QEP_QFLG_IEL_Msk /*!< Флаг прерывания по событию индексации */
|
||||
#define QEP_ITStatus_TMR QEP_QFLG_UTO_Msk /*!< Флаг прерывания по таймера временных отсчетов */
|
||||
#define QEP_ITStatus_All (QEP_ITStatus_GeneralInt | \
|
||||
QEP_ITStatus_PCError | \
|
||||
QEP_ITStatus_QuadPhaseError | \
|
||||
QEP_ITStatus_DirectionChange | \
|
||||
QEP_ITStatus_Watchdog | \
|
||||
QEP_ITStatus_PCOverflow | \
|
||||
QEP_ITStatus_PCUnderflow | \
|
||||
QEP_ITStatus_CMPShadowReady | \
|
||||
QEP_ITStatus_CMP | \
|
||||
QEP_ITStatus_Strobe | \
|
||||
QEP_ITStatus_Index | \
|
||||
QEP_ITStatus_TMR) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_QEP_IT_STATUS(VALUE) (((VALUE) & ~QEP_ITStatus_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_ITSource_Define Источники прерываний
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define QEP_ITSource_PCError QEP_QEINT_PCE_Msk /*!< Прерывание по ошибке счетчика позиции */
|
||||
#define QEP_ITSource_QuadPhaseError QEP_QEINT_QPE_Msk /*!< Прерывание по ошибке фазы на квадратурном входе */
|
||||
#define QEP_ITSource_DirectionChange QEP_QEINT_QDC_Msk /*!< Прерывание по смене направления вращения */
|
||||
#define QEP_ITSource_Watchdog QEP_QEINT_WTO_Msk /*!< Прерывание по срабатыванию сторожевого таймера */
|
||||
#define QEP_ITSource_PCOverflow QEP_QEINT_PCO_Msk /*!< Прерывание по переполнению счетчика позиции (переход через максимальное значение) */
|
||||
#define QEP_ITSource_PCUnderflow QEP_QEINT_PCU_Msk /*!< Прерывание по недозаполнению счетчика позиции (переход через минимальное значение) */
|
||||
#define QEP_ITSource_CMPShadowReady QEP_QEINT_PCR_Msk /*!< Прерывание по готовности компаратора к загрузке значения сравнения из отложенного регистра */
|
||||
#define QEP_ITSource_CMP QEP_QEINT_PCM_Msk /*!< Прерывание по срабатыванию компаратора */
|
||||
#define QEP_ITSource_Strobe QEP_QEINT_SEL_Msk /*!< Прерывание по событию стробирования */
|
||||
#define QEP_ITSource_Index QEP_QEINT_IEL_Msk /*!< Прерывание по событию индексации */
|
||||
#define QEP_ITSource_TMR QEP_QEINT_UTO_Msk /*!< Прерывание по таймера временных отсчетов */
|
||||
#define QEP_ITSource_All (QEP_ITSource_PCError | \
|
||||
QEP_ITSource_QuadPhaseError | \
|
||||
QEP_ITSource_DirectionChange | \
|
||||
QEP_ITSource_Watchdog | \
|
||||
QEP_ITSource_PCOverflow | \
|
||||
QEP_ITSource_PCUnderflow | \
|
||||
QEP_ITSource_CMPShadowReady | \
|
||||
QEP_ITSource_CMP | \
|
||||
QEP_ITSource_Strobe | \
|
||||
QEP_ITSource_Index | \
|
||||
QEP_ITSource_TMR) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_QEP_IT_SOURCE(VALUE) (((VALUE) & ~QEP_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор режима остановки таймеров QEP при отладке
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_Halt_Stop = QEP_QEPCTL_FREESOFT_Stop, /*!< Принудительная остановка */
|
||||
QEP_Halt_StopOnOverflow = QEP_QEPCTL_FREESOFT_StopAtOvf, /*!< Остановка после переполнения */
|
||||
QEP_Halt_Free = QEP_QEPCTL_FREESOFT_Free /*!< Без остановки */
|
||||
} QEP_Halt_TypeDef;
|
||||
#define IS_QEP_HALT(VALUE) (((VALUE) == QEP_Halt_Stop) || \
|
||||
((VALUE) == QEP_Halt_StopOnOverflow) || \
|
||||
((VALUE) == QEP_Halt_Free))
|
||||
|
||||
/**
|
||||
* @brief Режим счёта
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_Mode_Quad = QEP_QDECCTL_QSRC_Quad, /*!< Квадратурный режим счета */
|
||||
QEP_PC_Mode_CountDir = QEP_QDECCTL_QSRC_CountDir, /*!< Режим счета-направления */
|
||||
QEP_PC_Mode_CountUp = QEP_QDECCTL_QSRC_Up, /*!< Счет вверх */
|
||||
QEP_PC_Mode_CountDown = QEP_QDECCTL_QSRC_Down /*!< Счет вниз */
|
||||
} QEP_PC_Mode_TypeDef;
|
||||
#define IS_QEP_PC_MODE(VALUE) (((VALUE) == QEP_PC_Mode_Quad) || \
|
||||
((VALUE) == QEP_PC_Mode_CountDir) || \
|
||||
((VALUE) == QEP_PC_Mode_CountUp) || \
|
||||
((VALUE) == QEP_PC_Mode_CountDown))
|
||||
|
||||
/**
|
||||
* @brief Выбор скорости счета для режимов счета вверх или вниз
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_CountRate_Single, /*!< Счет по переднему фронту */
|
||||
QEP_PC_CountRate_Double /*!< Счет по обоим перепадам */
|
||||
} QEP_PC_CountRate_TypeDef;
|
||||
#define IS_QEP_PC_COUNT_RATE(VALUE) (((VALUE) == QEP_PC_CountRate_Single) || \
|
||||
((VALUE) == QEP_PC_CountRate_Double))
|
||||
|
||||
/**
|
||||
* @brief Выбор события для сброса счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_ResetEvent_Index = QEP_QEPCTL_PCRM_Ind, /*!< Событие индексации */
|
||||
QEP_PC_ResetEvent_CountMax = QEP_QEPCTL_PCRM_PosMax, /*!< Достижение счетчиком максимального значения */
|
||||
QEP_PC_ResetEvent_FirstIndex = QEP_QEPCTL_PCRM_FirstInd, /*!< Первое событие индексации */
|
||||
QEP_PC_ResetEvent_TMR = QEP_QEPCTL_PCRM_Time /*!< Окончание временного отсчета */
|
||||
} QEP_PC_ResetEvent_TypeDef;
|
||||
#define IS_QEP_PC_RESET_EVENT(VALUE) (((VALUE) == QEP_PC_ResetEvent_Index) || \
|
||||
((VALUE) == QEP_PC_ResetEvent_CountMax) || \
|
||||
((VALUE) == QEP_PC_ResetEvent_FirstIndex) || \
|
||||
((VALUE) == QEP_PC_ResetEvent_TMR))
|
||||
|
||||
/**
|
||||
* @brief Выбор события стробирования для инициализации счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_InitEventS_None = QEP_QEPCTL_SEI_NoInit, /*!< Без инициализации */
|
||||
QEP_PC_InitEventS_Rise = QEP_QEPCTL_SEI_QEPSPos, /*!< По переднему фронту S */
|
||||
QEP_PC_InitEventS_UpRiseDownFall = QEP_QEPCTL_SEI_QEPSDir, /*!< По переднему фронту S при счете вверх (вращение по часовой, вперед)
|
||||
и по заднему фронту S при счете вниз (вращение против часовой, назад) */
|
||||
} QEP_PC_InitEventS_TypeDef;
|
||||
#define IS_QEP_PC_INIT_EVENT_S(VALUE) (((VALUE) == QEP_PC_InitEventS_None) || \
|
||||
((VALUE) == QEP_PC_InitEventS_Rise) || \
|
||||
((VALUE) == QEP_PC_InitEventS_UpRiseDownFall))
|
||||
|
||||
/**
|
||||
* @brief Выбор события индексации для инициализации счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_InitEventI_None = QEP_QEPCTL_IEI_NoInit, /*!< Без инициализации */
|
||||
QEP_PC_InitEventI_Rise = QEP_QEPCTL_IEI_QEPIPos, /*!< По переднему фронту I */
|
||||
QEP_PC_InitEventI_Fall = QEP_QEPCTL_IEI_QEPINeg, /*!< По заднему фронту I */
|
||||
} QEP_PC_InitEventI_TypeDef;
|
||||
#define IS_QEP_PC_INIT_EVENT_I(VALUE) (((VALUE) == QEP_PC_InitEventI_None) || \
|
||||
((VALUE) == QEP_PC_InitEventI_Rise) || \
|
||||
((VALUE) == QEP_PC_InitEventI_Fall))
|
||||
|
||||
/**
|
||||
* @brief Выбор события стробирования для сохранения значения счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_LatchEventS_Rise, /*!< По переднему фронту S */
|
||||
QEP_PC_LatchEventS_UpRiseDownFall, /*!< По переднему фронту S при счете вверх (вращение по часовой, вперед)
|
||||
и по заднему фронту S при счете вниз (вращение против часовой, назад) */
|
||||
} QEP_PC_LatchEventS_TypeDef;
|
||||
#define IS_QEP_PC_LATCH_EVENT_S(VALUE) (((VALUE) == QEP_PC_LatchEventS_Rise) || \
|
||||
((VALUE) == QEP_PC_LatchEventS_UpRiseDownFall))
|
||||
|
||||
/**
|
||||
* @brief Выбор события индексации для сохранения значения счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_PC_LatchEventI_None = QEP_QEPCTL_IEL_NoLatch, /*!< Без сохранения */
|
||||
QEP_PC_LatchEventI_Rise = QEP_QEPCTL_IEL_IndPos, /*!< По переднему фронту I */
|
||||
QEP_PC_LatchEventI_Fall = QEP_QEPCTL_IEL_IndNeg, /*!< По заднему фронту I */
|
||||
QEP_PC_LatchEventI_Marker = QEP_QEPCTL_IEL_IndMark /*!< По маркеру индексации */
|
||||
} QEP_PC_LatchEventI_TypeDef;
|
||||
#define IS_QEP_PC_LATCH_EVENT_I(VALUE) (((VALUE) == QEP_PC_LatchEventI_None) || \
|
||||
((VALUE) == QEP_PC_LatchEventI_Rise) || \
|
||||
((VALUE) == QEP_PC_LatchEventI_Fall) || \
|
||||
((VALUE) == QEP_PC_LatchEventI_Marker))
|
||||
|
||||
/**
|
||||
* @brief Выбор события загрузки для отложенной записи значения сравнения счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CMP_LoadEvent_PCCountEqZero, /*!< Загрузка по равенству счетчика позиции нулю */
|
||||
QEP_CMP_LoadEvent_PCCountEqComp /*!< Загрузка по равенству счетчика позиции значению сравнения */
|
||||
} QEP_CMP_LoadEvent_TypeDef;
|
||||
#define IS_QEP_CMP_LOAD_EVENT(VALUE) (((VALUE) == QEP_CMP_LoadEvent_PCCountEqZero) || \
|
||||
((VALUE) == QEP_CMP_LoadEvent_PCCountEqComp))
|
||||
|
||||
/**
|
||||
* @brief Выбор вывода для выдачи выходного сигнала компаратора
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CMP_Out_S, /*!< Вывод сигнала строба */
|
||||
QEP_CMP_Out_I /*!< Вывод сигнала индекса */
|
||||
} QEP_CMP_Out_TypeDef;
|
||||
#define IS_QEP_CMP_OUT(VALUE) (((VALUE) == QEP_CMP_Out_S) || \
|
||||
((VALUE) == QEP_CMP_Out_I))
|
||||
|
||||
/**
|
||||
* @brief Выбор полярности выходного сигнала компаратора счетчика позиции
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CMP_OutPolarity_ActiveHigh, /*!< Активная единица */
|
||||
QEP_CMP_OutPolarity_ActiveLow, /*!< Активный ноль */
|
||||
} QEP_CMP_OutPolarity_TypeDef;
|
||||
#define IS_QEP_CMP_OUT_POLARITY(VALUE) (((VALUE) == QEP_CMP_OutPolarity_ActiveHigh) || \
|
||||
((VALUE) == QEP_CMP_OutPolarity_ActiveLow))
|
||||
|
||||
/**
|
||||
* @brief Выбор события для сброса таймера захвата
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CAP_ResetEvent_QCLKDiv, /*!< Деленное квадратурное событие */
|
||||
QEP_CAP_ResetEvent_CMPOut /*!< Выходной сигнал компаратора счетчика позиции */
|
||||
} QEP_CAP_ResetEvent_TypeDef;
|
||||
#define IS_QEP_CAP_RESET_EVENT(VALUE) (((VALUE) == QEP_CAP_ResetEvent_QCLKDiv) || \
|
||||
((VALUE) == QEP_CAP_ResetEvent_CMPOut))
|
||||
|
||||
/**
|
||||
* @brief Коэффициент деления тактового сигнала PCLK для таймера захвата
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CAP_PCLKDiv_1 = QEP_QCAPCTL_CCPS_Disable, /*!< Без деления тактовой частоты */
|
||||
QEP_CAP_PCLKDiv_2 = QEP_QCAPCTL_CCPS_Div2, /*!< Деление тактовой частоты на 2 */
|
||||
QEP_CAP_PCLKDiv_4 = QEP_QCAPCTL_CCPS_Div4, /*!< Деление тактовой частоты на 4 */
|
||||
QEP_CAP_PCLKDiv_8 = QEP_QCAPCTL_CCPS_Div8, /*!< Деление тактовой частоты на 8 */
|
||||
QEP_CAP_PCLKDiv_16 = QEP_QCAPCTL_CCPS_Div16, /*!< Деление тактовой частоты на 16 */
|
||||
QEP_CAP_PCLKDiv_32 = QEP_QCAPCTL_CCPS_Div32, /*!< Деление тактовой частоты на 32 */
|
||||
QEP_CAP_PCLKDiv_64 = QEP_QCAPCTL_CCPS_Div64, /*!< Деление тактовой частоты на 64 */
|
||||
QEP_CAP_PCLKDiv_128 = QEP_QCAPCTL_CCPS_Div128 /*!< Деление тактовой частоты на 128 */
|
||||
} QEP_CAP_PCLKDiv_TypeDef;
|
||||
#define IS_QEP_CAP_PCLK_DIV(VALUE) (((VALUE) == QEP_CAP_PCLKDiv_1) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_2) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_4) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_8) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_16) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_32) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_64) || \
|
||||
((VALUE) == QEP_CAP_PCLKDiv_128))
|
||||
|
||||
/**
|
||||
* @brief Коэффициент деления квадратурных событий
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CAP_QCLKDiv_1 = QEP_QCAPCTL_UPPS_Disable, /*!< Без деления квадратурных событий */
|
||||
QEP_CAP_QCLKDiv_2 = QEP_QCAPCTL_UPPS_Div2, /*!< Деление квадратурных событий на 2 */
|
||||
QEP_CAP_QCLKDiv_4 = QEP_QCAPCTL_UPPS_Div4, /*!< Деление квадратурных событий на 4 */
|
||||
QEP_CAP_QCLKDiv_8 = QEP_QCAPCTL_UPPS_Div8, /*!< Деление квадратурных событий на 8 */
|
||||
QEP_CAP_QCLKDiv_16 = QEP_QCAPCTL_UPPS_Div16, /*!< Деление квадратурных событий на 16 */
|
||||
QEP_CAP_QCLKDiv_32 = QEP_QCAPCTL_UPPS_Div32, /*!< Деление квадратурных событий на 32 */
|
||||
QEP_CAP_QCLKDiv_64 = QEP_QCAPCTL_UPPS_Div64, /*!< Деление квадратурных событий на 64 */
|
||||
QEP_CAP_QCLKDiv_128 = QEP_QCAPCTL_UPPS_Div128, /*!< Деление квадратурных событий на 128 */
|
||||
QEP_CAP_QCLKDiv_256 = QEP_QCAPCTL_UPPS_Div256, /*!< Деление квадратурных событий на 64 */
|
||||
QEP_CAP_QCLKDiv_512 = QEP_QCAPCTL_UPPS_Div512, /*!< Деление квадратурных событий на 128 */
|
||||
QEP_CAP_QCLKDiv_1024 = QEP_QCAPCTL_UPPS_Div1024, /*!< Деление квадратурных событий на 64 */
|
||||
QEP_CAP_QCLKDiv_2048 = QEP_QCAPCTL_UPPS_Div2048, /*!< Деление квадратурных событий на 128 */
|
||||
} QEP_CAP_QCLKDiv_TypeDef;
|
||||
#define IS_QEP_CAP_QCLK_DIV(VALUE) (((VALUE) == QEP_CAP_QCLKDiv_1) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_2) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_4) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_8) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_16) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_32) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_64) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_128) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_256) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_512) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_1024) || \
|
||||
((VALUE) == QEP_CAP_QCLKDiv_2048))
|
||||
|
||||
/**
|
||||
* @brief Выбор события для сохранения значения регистров модуля захвата
|
||||
*/
|
||||
typedef enum {
|
||||
QEP_CAP_LatchEvent_ReadPCCount, /*!< Чтение счетного регистра счетчика позиции */
|
||||
QEP_CAP_LatchEvent_TMRCountEqPeriod /*!< Равенство счетного регистра таймера периоду */
|
||||
} QEP_CAP_LatchEvent_TypeDef;
|
||||
#define IS_QEP_CAP_LATCH_EVENT(VALUE) (((VALUE) == QEP_CAP_LatchEvent_ReadPCCount) || \
|
||||
((VALUE) == QEP_CAP_LatchEvent_TMRCountEqPeriod))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации счётчика позиции
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
QEP_PC_Mode_TypeDef Mode;
|
||||
QEP_PC_CountRate_TypeDef CountRate;
|
||||
QEP_PC_ResetEvent_TypeDef ResetEvent;
|
||||
QEP_PC_InitEventS_TypeDef InitEventS;
|
||||
QEP_PC_InitEventI_TypeDef InitEventI;
|
||||
QEP_PC_LatchEventS_TypeDef LatchEventS;
|
||||
QEP_PC_LatchEventI_TypeDef LatchEventI;
|
||||
uint32_t Count;
|
||||
uint32_t CountInit;
|
||||
uint32_t CountMax;
|
||||
} QEP_PC_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации компаратора счётчика позиции
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState ShadowLoad;
|
||||
QEP_CMP_LoadEvent_TypeDef LoadEvent;
|
||||
QEP_CMP_Out_TypeDef Out;
|
||||
FunctionalState OutEn;
|
||||
QEP_CMP_OutPolarity_TypeDef OutPolarity;
|
||||
uint32_t OutWidth;
|
||||
uint32_t Comp;
|
||||
} QEP_CMP_Init_TypeDef;
|
||||
#define IS_QEP_CMP_OUT_WIDTH_VAL(VALUE) ((VALUE) < 0x1000)
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации модуля захвата времени
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
FunctionalState DivShadowLoad;
|
||||
QEP_CAP_ResetEvent_TypeDef ResetEvent;
|
||||
QEP_CAP_PCLKDiv_TypeDef PCLKDiv;
|
||||
QEP_CAP_QCLKDiv_TypeDef QCLKDiv;
|
||||
QEP_CAP_LatchEvent_TypeDef LatchEvent;
|
||||
uint32_t Count;
|
||||
uint32_t Period;
|
||||
} QEP_CAP_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
void QEP_DeInit(void);
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы выводов QEP
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_RemapCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(SIU->REMAPAF_bit.QEPEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос состояния выбранного флага
|
||||
* @param Flag Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений QEP_Flag_x из @ref QEP_Flag_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus QEP_FlagStatus(uint32_t Flag)
|
||||
{
|
||||
assert_param(IS_QEP_FLAG(Flag));
|
||||
|
||||
return (FlagStatus)READ_BIT(QEP->QEPSTS, Flag);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов
|
||||
* @param Status Выбор флагов.
|
||||
* Параметр принимает любою совокупность значений из @ref QEP_Flag_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_FlagStatusClear(uint32_t Flag)
|
||||
{
|
||||
assert_param(IS_QEP_FLAG(Flag));
|
||||
|
||||
WRITE_REG(QEP->QEPSTS, Flag);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима остановки всех счетчиков таймеров QEP
|
||||
* @param Halt Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_HaltConfig(QEP_Halt_TypeDef Halt)
|
||||
{
|
||||
assert_param(IS_QEP_HALT(Halt));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.FREESOFT, Halt);
|
||||
}
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_IO Управление входами
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение обмена входов A и B местами
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_SwapABCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.SWAP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение стробирования сигнала индекса
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_GateICmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.IGATE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение инверсии входа A
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_InvACmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.QAP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение инверсии входа B
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_InvBCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.QBP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение инверсии входа I (индекса)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_InvICmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.QIP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение инверсии входа S (строба)
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_IO_InvSCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.QSP, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_PositionCounter Счётчик позиции
|
||||
* @{
|
||||
*/
|
||||
|
||||
void QEP_PC_Init(QEP_PC_Init_TypeDef* InitStruct);
|
||||
void QEP_PC_StructInit(QEP_PC_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Включение счётчика позиции
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.QPEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима счета
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_ModeConfig(QEP_PC_Mode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_QEP_PC_MODE(Mode));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.QSRC, Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка скорости счета для режимов счета вверх или вниз
|
||||
* @param CountRate Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_CountRateConfig(QEP_PC_CountRate_TypeDef CountRate)
|
||||
{
|
||||
assert_param(IS_QEP_PC_COUNT_RATE(CountRate));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.XCR, CountRate);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события для сброса счетчика позиции
|
||||
* @param ResetEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_ResetEventConfig(QEP_PC_ResetEvent_TypeDef ResetEvent)
|
||||
{
|
||||
assert_param(IS_QEP_PC_RESET_EVENT(ResetEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.PCRM, ResetEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события стробирования для инициализации счетчика позиции
|
||||
* @param InitEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_InitEventSConfig(QEP_PC_InitEventS_TypeDef InitEvent)
|
||||
{
|
||||
assert_param(IS_QEP_PC_INIT_EVENT_S(InitEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.SEI, InitEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события индексации для инициализации счетчика позиции
|
||||
* @param InitEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_InitEventIConfig(QEP_PC_InitEventI_TypeDef InitEvent)
|
||||
{
|
||||
assert_param(IS_QEP_PC_INIT_EVENT_I(InitEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.IEI, InitEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выполнение программной инициализации счетчика позиции
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_SwInitCmd(void)
|
||||
{
|
||||
WRITE_REG(QEP->QEPCTL_bit.SWI, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события стробирования для сохранения счетчика позиции
|
||||
* @param InitEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_LatchEventSConfig(QEP_PC_LatchEventS_TypeDef LatchEvent)
|
||||
{
|
||||
assert_param(IS_QEP_PC_LATCH_EVENT_S(LatchEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.SEL, LatchEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события индексации для сохранения счетчика позиции
|
||||
* @param InitEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_LatchEventIConfig(QEP_PC_LatchEventI_TypeDef LatchEvent)
|
||||
{
|
||||
assert_param(IS_QEP_PC_LATCH_EVENT_I(LatchEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.IEL, LatchEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика позиции
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_SetCount(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QPOSCNT, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика позиции
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCount(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSCNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения инициализации счетчика позиции
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_SetCountInit(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QPOSINIT, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения инициализации счетчика позиции
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCountInit(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSINIT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка максимального значения счетчика позиции
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_PC_SetCountMax(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QPOSMAX, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего максимального значения счетчика позиции
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCountMax(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSMAX);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение сохраненного значения счетчика позиции по стробу
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCountLatchS(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSSLAT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение сохраненного значения счетчика позиции по индексу
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCountLatchI(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSILAT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_PositionCompare Компаратор
|
||||
* @{
|
||||
*/
|
||||
|
||||
void QEP_CMP_Init(QEP_CMP_Init_TypeDef* InitStruct);
|
||||
void QEP_CMP_StructInit(QEP_CMP_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Включение компаратора счётчика позиции
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QPOSCTL_bit.PCE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение отложенной загрузки компаратора счётчика позиции
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_ShadowLoadCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QPOSCTL_bit.PCSHDW, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события для отложенной загрузки компаратора счётчика позиции
|
||||
* @param LoadEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_LoadEventConfig(QEP_CMP_LoadEvent_TypeDef LoadEvent)
|
||||
{
|
||||
assert_param(IS_QEP_CMP_LOAD_EVENT(LoadEvent));
|
||||
|
||||
WRITE_REG(QEP->QPOSCTL_bit.PCLOAD, LoadEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка вывода для выдачи выходного сигнала компаратора счётчика позиции
|
||||
* @param Out Выбор вывода
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_OutConfig(QEP_CMP_Out_TypeDef Out)
|
||||
{
|
||||
assert_param(IS_QEP_CMP_OUT(Out));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.SPSEL, Out);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение выходного сигнала компаратора счётчика позиции
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_OutCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QDECCTL_bit.SOEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка полярности выходного сигнала компаратора счетчика позиции
|
||||
* @param OutPolarity Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_OutPolarityConfig(QEP_CMP_OutPolarity_TypeDef OutPolarity)
|
||||
{
|
||||
assert_param(IS_QEP_CMP_OUT_POLARITY(OutPolarity));
|
||||
|
||||
WRITE_REG(QEP->QPOSCTL_bit.PCPOL, OutPolarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка ширигы импульса выходного сигнала компаратора счетчика позиции
|
||||
* @param OutPolarity Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_SetOutWidth(uint32_t OutWidth)
|
||||
{
|
||||
assert_param(IS_QEP_CMP_OUT_WIDTH_VAL(OutWidth));
|
||||
|
||||
WRITE_REG(QEP->QPOSCTL_bit.PCSPW, OutWidth);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения компаратора счетчика позиции
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CMP_SetComp(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QPOSCMP, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения компаратора счетчика позиции
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_CMP_GetComp(void)
|
||||
{
|
||||
return READ_REG(QEP->QPOSCMP);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_CaptureTime Модуль захвата времени
|
||||
* @{
|
||||
*/
|
||||
|
||||
void QEP_CAP_Init(QEP_CAP_Init_TypeDef* InitStruct);
|
||||
void QEP_CAP_StructInit(QEP_CAP_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @brief Включение модуля захвата времени
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QCAPCTL_bit.CEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение теневой загрузки делителей модуля захвата времени
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_DivShadowLoadCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QCAPCTL_bit.EPSLD, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события сброса счетчика модуля захвата времени
|
||||
* @param ResetEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_ResetEventConfig(QEP_CAP_ResetEvent_TypeDef ResetEvent)
|
||||
{
|
||||
assert_param(IS_QEP_CAP_RESET_EVENT(ResetEvent));
|
||||
|
||||
WRITE_REG(QEP->QCAPCTL_bit.SELEVENT, ResetEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка делителей для модуля захвата времени
|
||||
* @param PCLKDiv Выбор делителя PCLK
|
||||
* @param QCLKDiv Выбор делителя QCLK
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_DivConfig(QEP_CAP_PCLKDiv_TypeDef PCLKDiv, QEP_CAP_QCLKDiv_TypeDef QCLKDiv)
|
||||
{
|
||||
assert_param(IS_QEP_CAP_PCLK_DIV(PCLKDiv));
|
||||
assert_param(IS_QEP_CAP_QCLK_DIV(QCLKDiv));
|
||||
|
||||
MODIFY_REG(QEP->QCAPCTL, QEP_QCAPCTL_CCPS_Msk | QEP_QCAPCTL_UPPS_Msk,
|
||||
((PCLKDiv << QEP_QCAPCTL_CCPS_Pos) | (QCLKDiv << QEP_QCAPCTL_UPPS_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка делителя PCLK для модуля захвата времени
|
||||
* @param PCLKDiv Выбор делителя
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_PCLKDivConfig(QEP_CAP_PCLKDiv_TypeDef PCLKDiv)
|
||||
{
|
||||
assert_param(IS_QEP_CAP_PCLK_DIV(PCLKDiv));
|
||||
|
||||
WRITE_REG(QEP->QCAPCTL_bit.CCPS, PCLKDiv);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка делителя QCLK для модуля захвата времени
|
||||
* @param QCLKDiv Выбор делителя
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_QCLKDivConfig(QEP_CAP_QCLKDiv_TypeDef QCLKDiv)
|
||||
{
|
||||
assert_param(IS_QEP_CAP_QCLK_DIV(QCLKDiv));
|
||||
|
||||
WRITE_REG(QEP->QCAPCTL_bit.UPPS, QCLKDiv);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка события сохранения значения регистров модуля захвата
|
||||
* @param LatchEvent Выбор события
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_LatchEventConfig(QEP_CAP_LatchEvent_TypeDef LatchEvent)
|
||||
{
|
||||
assert_param(IS_QEP_CAP_LATCH_EVENT(LatchEvent));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.QCLM, LatchEvent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика модуля захвата
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_SetCount(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QCTMR, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика модуля захвата
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_CAP_GetCount(void)
|
||||
{
|
||||
return READ_REG(QEP->QCTMR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода модуля захвата
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_SetPeriod(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QCPRD, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения периода модуля захвата
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_CAP_GetPeriod(void)
|
||||
{
|
||||
return READ_REG(QEP->QCPRD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение сохраненного значения счетчика модуля захвата
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetCountLatch(void)
|
||||
{
|
||||
return READ_REG(QEP->QCTMRLAT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение сохраненного значения периода модуля захвата
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_PC_GetPeriodLatch(void)
|
||||
{
|
||||
return READ_REG(QEP->QCPRDLAT);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение генерации запроса DMA событию захвата
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_CAP_DMACmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->DMAREQ_bit.DMAEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_UnitTimer Таймер временных отсчетов
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение таймера временных отсчетов
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_TMR_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.UTE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика таймера временных отсчетов
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_TMR_SetCount(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QUTMR, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения счетчика таймера временных отсчетов
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_TMR_GetCount(void)
|
||||
{
|
||||
return READ_REG(QEP->QUTMR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода таймера временных отсчетов
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_TMR_SetPeriod(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QUPRD, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения периода таймера временных отсчетов
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_TMR_GetPeriod(void)
|
||||
{
|
||||
return READ_REG(QEP->QUPRD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_Watchdog Сторожевой таймер
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Включение сторожевого таймера
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_WDT_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(QEP->QEPCTL_bit.WDE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика сторожевого таймера
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_WDT_SetCount(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QWDTMR, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения счетчика сторожевого таймера
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_WDT_GetCount(void)
|
||||
{
|
||||
return READ_REG(QEP->QWDTMR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения периода сторожевого таймера
|
||||
* @param Val Значение
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_WDT_SetPeriod(uint32_t Val)
|
||||
{
|
||||
WRITE_REG(QEP->QWDPRD, Val);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения периода сторожевого таймера
|
||||
* @retval Val Значение
|
||||
*/
|
||||
__STATIC_INLINE uint32_t QEP_WDT_GetPeriod(void)
|
||||
{
|
||||
return READ_REG(QEP->QWDPRD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Exported_Functions_IT Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации прерываний
|
||||
* @param ITSource Выбор источников прерывания
|
||||
* Параметр принимает любою совокупность значений QEP_ITSource_x из @ref QEP_ITSource_define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_ITCmd(uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_QEP_IT_SOURCE(ITSource));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
MODIFY_REG(QEP->QEINT, ITSource, State ? (uint32_t)ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Принудительный вызов прерывания
|
||||
* @param ITSource Выбор источников прерывания
|
||||
* Параметр принимает любою совокупность значений QEP_ITSource_x из @ref QEP_ITSource_define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_ITForceCmd(uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_QEP_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(QEP->QFRC, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса прерывания
|
||||
* @param ITStatus Выбор флага прерывания.
|
||||
* Параметр принимает любою совокупность значений QEP_ITStatus_x из @ref QEP_ITStatus_define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus QEP_ITStatus(uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_QEP_IT_STATUS(ITStatus));
|
||||
|
||||
return (FlagStatus)READ_BIT(QEP->QFLG, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение сохраненного статуса прерывания (сохранение каждый раз при чтении счетчика позиции)
|
||||
* @param ITStatus Выбор флага прерывания.
|
||||
* Параметр принимает любою совокупность значений QEP_ITStatus_x из @ref QEP_ITStatus_define.
|
||||
* @retval Status Статус прерывания. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus QEP_ITStatusLatch(uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_QEP_IT_STATUS(ITStatus));
|
||||
|
||||
return (FlagStatus)READ_BIT(QEP->QFLG, ITStatus << QEP_QFLG_QFLGLAT_Pos);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс статуса прерывания
|
||||
* @param ITStatus Выбор флага прерывания.
|
||||
* Параметр принимает любою совокупность значений QEP_ITStatus_x из @ref QEP_ITStatus_define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_ITStatusClear(uint32_t ITStatus)
|
||||
{
|
||||
assert_param(IS_QEP_IT_STATUS(ITStatus));
|
||||
|
||||
WRITE_REG(QEP->QCLR, ITStatus);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение активного статуса прерывания
|
||||
* @retval Status Статус прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus QEP_ITPendStatus(void)
|
||||
{
|
||||
return (FlagStatus)READ_BIT(QEP->INTCLR, QEP_INTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс активности прерывания
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void QEP_ITPendStatusClear(void)
|
||||
{
|
||||
WRITE_REG(QEP->INTCLR, QEP_INTCLR_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_QEP_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
955
MDK-ARM/platform/plib035/inc/plib035_rcu.h
Normal file
955
MDK-ARM/platform/plib035/inc/plib035_rcu.h
Normal file
@@ -0,0 +1,955 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @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****/
|
||||
491
MDK-ARM/platform/plib035/inc/plib035_spi.h
Normal file
491
MDK-ARM/platform/plib035/inc/plib035_spi.h
Normal file
@@ -0,0 +1,491 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_spi.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* SPI, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_SPI_H
|
||||
#define __PLIB035_SPI_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup SPI
|
||||
* @brief Драйвер для работы с SPI
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_ITSource_Define Источники прерываний SPI
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define SPI_ITSource_RecieveTimeout SPI_IMSC_RTIM_Msk /*!< Таймаут приема данных */
|
||||
#define SPI_ITSource_RecieveOverrun SPI_IMSC_RORIM_Msk /*!< Переполнение буфера приемника */
|
||||
#define SPI_ITSource_RxFIFOLevel SPI_IMSC_RXIM_Msk /*!< Порог переполнения буфера приемника */
|
||||
#define SPI_ITSource_TxFIFOLevel SPI_IMSC_TXIM_Msk /*!< Порог опустошения буфера передатчика */
|
||||
#define SPI_ITSource_All (SPI_IMSC_RTIM_Msk | \
|
||||
SPI_IMSC_RORIM_Msk | \
|
||||
SPI_IMSC_RXIM_Msk | \
|
||||
SPI_IMSC_TXIM_Msk) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_SPI_IT_SOURCE(VALUE) (((VALUE) & ~SPI_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Flag_Define Флаги работы SPI
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define SPI_Flag_Busy SPI_SR_BSY_Msk /*!< Флаг занятости блока SPI */
|
||||
#define SPI_Flag_RxFIFONotEmpty SPI_SR_RNE_Msk /*!< Флаг наличия данных в буффере приемника данных */
|
||||
#define SPI_Flag_RxFIFOFull SPI_SR_RFF_Msk /*!< Флаг заполнения буффера приемника */
|
||||
#define SPI_Flag_TxFIFONotFull SPI_SR_TNF_Msk /*!< Флаг наличия свободного места в буффере передатчика */
|
||||
#define SPI_Flag_TxFIFOEmpty SPI_SR_TFE_Msk /*!< Флаг пустоты буффера передатчика */
|
||||
#define SPI_Flag_All (SPI_SR_BSY_Msk | \
|
||||
SPI_SR_RNE_Msk | \
|
||||
SPI_SR_RFF_Msk | \
|
||||
SPI_SR_TNF_Msk | \
|
||||
SPI_SR_TFE_Msk) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_SPI_FLAG(VALUE) (((VALUE) & ~SPI_Flag_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Выбор фазы сигнала SCK (только режим SPI)
|
||||
*/
|
||||
typedef enum {
|
||||
SPI_SCKPhase_CaptureRise, /*!< Захват данных по переднему фронту SCK, установка по заднему */
|
||||
SPI_SCKPhase_CaptureFall /*!< Захват данных по заднему фронту SCK, установка по переднему */
|
||||
} SPI_SCKPhase_TypeDef;
|
||||
#define IS_SPI_SCK_PHASE(VALUE) (((VALUE) == SPI_SCKPhase_CaptureRise) || \
|
||||
((VALUE) == SPI_SCKPhase_CaptureFall))
|
||||
|
||||
/**
|
||||
* @brief Выбор полярности сигнала SCK (только режим SPI)
|
||||
*/
|
||||
typedef enum {
|
||||
SPI_SCKPolarity_SteadyLow, /*!< В режиме ожидания SCK удерживается в состоянии нуля */
|
||||
SPI_SCKPolarity_SteadyHigh /*!< В режиме ожидания SCK удерживается в состоянии единицы */
|
||||
} SPI_SCKPolarity_TypeDef;
|
||||
#define IS_SPI_SCK_POLARITY(VALUE) (((VALUE) == SPI_SCKPolarity_SteadyLow) || \
|
||||
((VALUE) == SPI_SCKPolarity_SteadyHigh))
|
||||
|
||||
/**
|
||||
* @brief Выбор формата кадра
|
||||
*/
|
||||
typedef enum {
|
||||
SPI_FrameFormat_SPI = SPI_CR0_FRF_SPI, /*!< Режим SPI от Motorola */
|
||||
SPI_FrameFormat_SSI = SPI_CR0_FRF_SSI, /*!< Режим SSI от Texas Instruments */
|
||||
SPI_FrameFormat_Microwire = SPI_CR0_FRF_Microwire, /*!< Режим Microwire от National Semiconductor */
|
||||
} SPI_FrameFormat_TypeDef;
|
||||
#define IS_SPI_FRAME_FORMAT(VALUE) (((VALUE) == SPI_FrameFormat_SPI) || \
|
||||
((VALUE) == SPI_FrameFormat_SSI) || \
|
||||
((VALUE) == SPI_FrameFormat_Microwire))
|
||||
|
||||
/**
|
||||
* @brief Размер слова данных
|
||||
*/
|
||||
typedef enum {
|
||||
SPI_DataWidth_4 = SPI_CR0_DSS_4bit, /*!< Длина информационного слова 4 бит */
|
||||
SPI_DataWidth_5 = SPI_CR0_DSS_5bit, /*!< Длина информационного слова 5 бит */
|
||||
SPI_DataWidth_6 = SPI_CR0_DSS_6bit, /*!< Длина информационного слова 6 бит */
|
||||
SPI_DataWidth_7 = SPI_CR0_DSS_7bit, /*!< Длина информационного слова 7 бит */
|
||||
SPI_DataWidth_8 = SPI_CR0_DSS_8bit, /*!< Длина информационного слова 8 бит */
|
||||
SPI_DataWidth_9 = SPI_CR0_DSS_9bit, /*!< Длина информационного слова 9 бит */
|
||||
SPI_DataWidth_10 = SPI_CR0_DSS_10bit, /*!< Длина информационного слова 10 бит */
|
||||
SPI_DataWidth_11 = SPI_CR0_DSS_11bit, /*!< Длина информационного слова 11 бит */
|
||||
SPI_DataWidth_12 = SPI_CR0_DSS_12bit, /*!< Длина информационного слова 12 бит */
|
||||
SPI_DataWidth_13 = SPI_CR0_DSS_13bit, /*!< Длина информационного слова 13 бит */
|
||||
SPI_DataWidth_14 = SPI_CR0_DSS_14bit, /*!< Длина информационного слова 14 бит */
|
||||
SPI_DataWidth_15 = SPI_CR0_DSS_15bit, /*!< Длина информационного слова 15 бит */
|
||||
SPI_DataWidth_16 = SPI_CR0_DSS_16bit, /*!< Длина информационного слова 16 бит */
|
||||
} SPI_DataWidth_TypeDef;
|
||||
#define IS_SPI_DATA_WIDTH(VALUE) (((VALUE) == SPI_DataWidth_4) || \
|
||||
((VALUE) == SPI_DataWidth_5) || \
|
||||
((VALUE) == SPI_DataWidth_6) || \
|
||||
((VALUE) == SPI_DataWidth_7) || \
|
||||
((VALUE) == SPI_DataWidth_8) || \
|
||||
((VALUE) == SPI_DataWidth_9) || \
|
||||
((VALUE) == SPI_DataWidth_10) || \
|
||||
((VALUE) == SPI_DataWidth_11) || \
|
||||
((VALUE) == SPI_DataWidth_12) || \
|
||||
((VALUE) == SPI_DataWidth_13) || \
|
||||
((VALUE) == SPI_DataWidth_14) || \
|
||||
((VALUE) == SPI_DataWidth_15) || \
|
||||
((VALUE) == SPI_DataWidth_16))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы
|
||||
*/
|
||||
typedef enum {
|
||||
SPI_Mode_Master, /*!< Мастер */
|
||||
SPI_Mode_Slave /*!< Ведомый */
|
||||
} SPI_Mode_TypeDef;
|
||||
#define IS_SPI_MODE(VALUE) (((VALUE) == SPI_Mode_Master) || \
|
||||
((VALUE) == SPI_Mode_Slave))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации SPI
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
SPI_Mode_TypeDef Mode; /*!< Выбор режима работы */
|
||||
SPI_FrameFormat_TypeDef FrameFormat; /*!< Выбор формата кадра */
|
||||
SPI_DataWidth_TypeDef DataWidth; /*!< Количество передаваемых/принимаемых информационных бит */
|
||||
uint32_t SCKDiv; /*!< Коэффициент базового деления частоты.
|
||||
Параметр может принимать любое значение из диапазона: 0-255. */
|
||||
uint32_t SCKDivExtra; /*!< Коэффициент дополнительного деления частоты.
|
||||
Параметр может принимать любые четные значения из диапазона: 2-254.
|
||||
Результирующий коэффциент = SCKDivExtra * (1 + SCKDiv). */
|
||||
} SPI_Init_TypeDef;
|
||||
|
||||
#define IS_SPI_SCK_DIV(VALUE) (((VALUE) > 0) && ((VALUE) < 0x100))
|
||||
#define IS_SPI_SCK_DIV_EXTRA(VALUE) (((VALUE) > 1) && ((VALUE) < 0xFF))
|
||||
#define IS_SPI_DATA(VALUE) ((VALUE) < 0x10000)
|
||||
#define IS_SPI_FIFO_LEVEL(VALUE) ((VALUE) < 9)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы приемопередатчика SPI
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(SPI->CR1_bit.SSE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Отключение выхода данных в режиме ведомого
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_SlaveOutputDisCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(SPI->CR1_bit.SOD, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка полярности и фазы SCK в режиме SPI Motorola
|
||||
* @param SCKPhase Режим фазы
|
||||
* @param SCKPhase Режим полярности
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_SCKConfig(SPI_SCKPhase_TypeDef SCKPhase, SPI_SCKPolarity_TypeDef SCKPolarity)
|
||||
{
|
||||
assert_param(IS_SPI_SCK_PHASE(SCKPhase));
|
||||
assert_param(IS_SPI_SCK_POLARITY(SCKPolarity));
|
||||
|
||||
MODIFY_REG(SPI->CR0, SPI_CR0_SPH_Msk | SPI_CR0_SPO_Msk,
|
||||
((SCKPhase << SPI_CR0_SPH_Pos) |
|
||||
(SCKPolarity << SPI_CR0_SPO_Pos)));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка ширины слова данных
|
||||
* @param DataWidth Значение разрядности слова
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_DataWidthConfig(SPI_DataWidth_TypeDef DataWidth)
|
||||
{
|
||||
assert_param(IS_SPI_DATA_WIDTH(DataWidth));
|
||||
|
||||
WRITE_REG(SPI->CR0_bit.DSS, DataWidth);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима работы SPI
|
||||
* @param Mode Выбор режима
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_ModeConfig(SPI_Mode_TypeDef Mode)
|
||||
{
|
||||
assert_param(IS_SPI_MODE(Mode));
|
||||
|
||||
WRITE_REG(SPI->CR1_bit.MS, Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима формата кадра
|
||||
* @param FrameFormat Выбор формата
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_FrameFormatConfig(SPI_FrameFormat_TypeDef FrameFormat)
|
||||
{
|
||||
assert_param(IS_SPI_FRAME_FORMAT(FrameFormat));
|
||||
|
||||
WRITE_REG(SPI->CR0_bit.FRF, FrameFormat);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка делителя для получение нужной частоты SCK.
|
||||
* Результирующий коэффциент деления = SCKDivExtra * (1 + SCKDiv).
|
||||
* @param SCKDiv Основной делитель.
|
||||
* Параметр принимает любое значение из диапазона 0-255.
|
||||
* @param SCKDivExtra Дополнительный делитель.
|
||||
Параметр может принимать любые четные значения из диапазона: 2-254.
|
||||
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_SCKDivConfig(uint32_t SCKDiv, uint32_t SCKDivExtra)
|
||||
{
|
||||
assert_param(IS_SPI_SCK_DIV(SCKDiv));
|
||||
assert_param(IS_SPI_SCK_DIV_EXTRA(SCKDivExtra));
|
||||
|
||||
WRITE_REG(SPI->CR0_bit.SCR, SCKDiv);
|
||||
WRITE_REG(SPI->CPSR, SCKDivExtra);
|
||||
}
|
||||
|
||||
/** @defgroup SPI_Init_Deinit Инициализация и деинициализация
|
||||
* @{
|
||||
*/
|
||||
|
||||
void SPI_DeInit(void);
|
||||
void SPI_Init(SPI_Init_TypeDef* InitStruct);
|
||||
void SPI_StructInit(SPI_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_SendRecieve Прием и передача
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Передача слова данных
|
||||
* @param Data Слово данных
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_SendData(uint32_t Data)
|
||||
{
|
||||
assert_param(IS_SPI_DATA(Data));
|
||||
|
||||
WRITE_REG(SPI->DR, Data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Прием слова данных
|
||||
* @retval Val Слово данных
|
||||
*/
|
||||
__STATIC_INLINE uint32_t SPI_RecieveData()
|
||||
{
|
||||
return READ_REG(SPI->DR);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос состояния выбранного флага
|
||||
* @param Flag Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений SPI_Flag_x из @ref SPI_Flag_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus SPI_FlagStatus(uint32_t Flag)
|
||||
{
|
||||
assert_param(IS_SPI_FLAG(Flag));
|
||||
|
||||
return (FlagStatus)READ_BIT(SPI->SR, Flag);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_IT Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка порога заполнения FIFO при приёме для генерации прерывания
|
||||
* @param FIFOLevelRx Порог.
|
||||
* Параметр принимает любое значение из диапазона 0-8.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_ITFIFOLevelRxConfig(uint32_t FIFOLevelRx)
|
||||
{
|
||||
assert_param(IS_SPI_FIFO_LEVEL(FIFOLevelRx));
|
||||
|
||||
WRITE_REG(SPI->CR1_bit.RXIFLSEL, FIFOLevelRx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка порога опустошения FIFO при передаче для генерации прерывания
|
||||
* @param FIFOLevelTx Порог.
|
||||
* Параметр принимает любое значение из диапазона 0-8.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_ITFIFOLevelTxConfig(uint32_t FIFOLevelTx)
|
||||
{
|
||||
assert_param(IS_SPI_FIFO_LEVEL(FIFOLevelTx));
|
||||
|
||||
WRITE_REG(SPI->CR1_bit.TXIFLSEL, FIFOLevelTx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Маскирование выбранных прерываний
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений SPI_ITSource_x из @ref SPI_ITSource_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_ITCmd(uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_SPI_IT_SOURCE(ITSource));
|
||||
|
||||
MODIFY_REG(SPI->IMSC, ITSource, State ? ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос немаскированного состояния прерывания
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений SPI_ITSource_x из @ref SPI_ITSource_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus SPI_ITRawStatus(uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_SPI_IT_SOURCE(ITSource));
|
||||
|
||||
return (FlagStatus)READ_BIT(SPI->RIS, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос маскированного состояния прерывания
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений SPI_ITSource_x из @ref SPI_ITSource_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus SPI_ITMaskedStatus(uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_SPI_IT_SOURCE(ITSource));
|
||||
|
||||
return (FlagStatus)READ_BIT(SPI->MIS, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов состояния выбранных прерываний
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений SPI_ITSource_x из @ref SPI_ITSource_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_ITStatusClear(uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_SPI_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(SPI->ICR, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_DMA Настройка DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение формирования запросов DMA для обслуживания буфера приемника
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_DMARxCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(SPI->DMACR_bit.RXDMAE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение формирования запросов DMA для обслуживания буфера передатчика
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void SPI_DMATxCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(SPI->DMACR_bit.TXDMAE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_SPI_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
245
MDK-ARM/platform/plib035/inc/plib035_tmr.h
Normal file
245
MDK-ARM/platform/plib035/inc/plib035_tmr.h
Normal file
@@ -0,0 +1,245 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_tmr.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* TMR, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_TMR_H
|
||||
#define __PLIB035_TMR_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup TMR
|
||||
* @brief Драйвер для работы с TMR
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка внешнего тактирования таймера
|
||||
*/
|
||||
typedef enum {
|
||||
TMR_ExtInput_Disable = 0x0UL, /*!< Внешнее тактирование не используется */
|
||||
TMR_ExtInput_CountClk = TMR_CTRL_EXTINEN_Msk | TMR_CTRL_EXTINCLK_Msk, /*!< Таймер считает по внешнему тактовому сигналу */
|
||||
TMR_ExtInput_CountEn = TMR_CTRL_EXTINEN_Msk /*!< Таймер считает по внутреннему тактовому сигналу и только тогда, когда на выводе "1" */
|
||||
} TMR_ExtInput_TypeDef;
|
||||
#define IS_TMR_EXT_INPUT(VALUE) (((VALUE) == TMR_ExtInput_Disable) || \
|
||||
((VALUE) == TMR_ExtInput_CountClk) || \
|
||||
((VALUE) == TMR_ExtInput_CountEn))
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы выбранного таймера
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_Cmd(TMR_TypeDef* TMRx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(TMRx->CTRL_bit.ON, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения перезагрузки
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param LoadVal Значение перезагрузки
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_SetLoad(TMR_TypeDef* TMRx, uint32_t LoadVal)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
WRITE_REG(TMRx->LOAD, LoadVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения перезагрузки
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @retval Val Значение перезагрузки
|
||||
*/
|
||||
__STATIC_INLINE uint32_t TMR_GetLoad(TMR_TypeDef* TMRx)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
return READ_REG(TMRx->LOAD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения счетчика
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param CounterVal Значение счетчика
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_SetCounter(TMR_TypeDef* TMRx, uint32_t CounterVal)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
WRITE_REG(TMRx->VALUE, CounterVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика.
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @retval Val Значение счетчика
|
||||
*/
|
||||
__STATIC_INLINE uint32_t TMR_GetCounter(TMR_TypeDef* TMRx)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
return READ_REG(TMRx->VALUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выбор режима работы входа внешнего тактирования.
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param TMR_ExtInput Выбор режима работы
|
||||
* @retval void
|
||||
*/
|
||||
|
||||
__STATIC_INLINE void TMR_ExtInputConfig(TMR_TypeDef* TMRx, TMR_ExtInput_TypeDef ExtInput)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
assert_param(IS_TMR_EXT_INPUT(ExtInput));
|
||||
|
||||
MODIFY_REG(TMRx->CTRL, TMR_CTRL_EXTINEN_Msk | TMR_CTRL_EXTINCLK_Msk, ExtInput);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы прерывания выбранного таймера
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_ITCmd(TMR_TypeDef* TMRx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(TMRx->CTRL_bit.INTEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение статуса прерывания выбранного таймера
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @retval Status Статус прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus TMR_ITStatus(TMR_TypeDef* TMRx)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
return (FlagStatus)READ_BIT(TMRx->INTSTATUS, TMR_INTSTATUS_INT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Очищение статусного бита прерывания выбранного таймера.
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_ITStatusClear(TMR_TypeDef* TMRx)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
|
||||
WRITE_REG(TMRx->INTSTATUS, TMR_INTSTATUS_INT_Msk);
|
||||
}
|
||||
|
||||
void TMR_PeriodConfig(TMR_TypeDef* TMRx, uint32_t TimerClkFreq, uint32_t TimerPeriod);
|
||||
void TMR_FreqConfig(TMR_TypeDef* TMRx, uint32_t TimerClkFreq, uint32_t TimerFreq);
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации запросов к DMA
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_DMAReqCmd(TMR_TypeDef* TMRx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(TMRx->DMAREQ_bit.EN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение генерации сигналов запуска АЦП
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void TMR_ADCSOCCmd(TMR_TypeDef* TMRx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_TMR_PERIPH(TMRx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(TMRx->ADCSOC_bit.EN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_TMR_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
606
MDK-ARM/platform/plib035/inc/plib035_uart.h
Normal file
606
MDK-ARM/platform/plib035/inc/plib035_uart.h
Normal file
@@ -0,0 +1,606 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_uart.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* UART, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_UART_H
|
||||
#define __PLIB035_UART_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup UART
|
||||
* @brief Драйвер для работы с UART
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup UART_ITSource_Define Источники прерываний UART
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define UART_ITSource_RxFIFOLevel UART_IMSC_RXIM_Msk /*!< Порог переполнения буфера приемника */
|
||||
#define UART_ITSource_TxFIFOLevel UART_IMSC_TXIM_Msk /*!< Порог опустошения буфера передатчика */
|
||||
#define UART_ITSource_RecieveTimeout UART_IMSC_RTIM_Msk /*!< Таймаут приема данных */
|
||||
#define UART_ITSource_ErrorFrame UART_IMSC_FEIM_Msk /*!< Ошибка в структуре кадра */
|
||||
#define UART_ITSource_ErrorParity UART_IMSC_PEIM_Msk /*!< Ошибка контроля четности */
|
||||
#define UART_ITSource_ErrorBreak UART_IMSC_BEIM_Msk /*!< Разрыв линии */
|
||||
#define UART_ITSource_ErrorOverflow UART_IMSC_OEIM_Msk /*!< Переполнение буффера приемника */
|
||||
#define UART_ITSource_TransmitDone UART_IMSC_TDIM_Msk /*!< Окончание передачи в линии */
|
||||
#define UART_ITSource_All (UART_IMSC_RXIM_Msk | \
|
||||
UART_IMSC_TXIM_Msk | \
|
||||
UART_IMSC_RTIM_Msk | \
|
||||
UART_IMSC_FEIM_Msk | \
|
||||
UART_IMSC_PEIM_Msk | \
|
||||
UART_IMSC_BEIM_Msk | \
|
||||
UART_IMSC_OEIM_Msk | \
|
||||
UART_IMSC_TDIM_Msk) /*!< Все источники выбраны */
|
||||
|
||||
#define IS_UART_IT_SOURCE(VALUE) (((VALUE) & ~UART_ITSource_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Flag_Define Флаги работы UART
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define UART_Flag_Busy UART_FR_BUSY_Msk /*!< Флаг занятости блока UART */
|
||||
#define UART_Flag_RxFIFOEmpty UART_FR_RXFE_Msk /*!< Флаг пустоты буффера приемника */
|
||||
#define UART_Flag_TxFIFOFull UART_FR_TXFF_Msk /*!< Флаг заполнения буффера передатчика */
|
||||
#define UART_Flag_RxFIFOFull UART_FR_RXFF_Msk /*!< Флаг заполнения буффера приемника */
|
||||
#define UART_Flag_TxFIFOEmpty UART_FR_TXFE_Msk /*!< Флаг пустоты буффера передатчика */
|
||||
#define UART_Flag_All (UART_FR_BUSY_Msk | \
|
||||
UART_FR_RXFE_Msk | \
|
||||
UART_FR_TXFF_Msk | \
|
||||
UART_FR_RXFF_Msk | \
|
||||
UART_FR_TXFE_Msk) /*!< Все флаги выбраны */
|
||||
|
||||
#define IS_UART_FLAG(VALUE) (((VALUE) & ~UART_Flag_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Error_Define Ошибки приемника UART
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define UART_Error_Frame UART_RSR_FE_Msk /*!< Флаг ошибки в структуре кадра */
|
||||
#define UART_Error_Parity UART_RSR_PE_Msk /*!< Флаг ошибки контроля четности */
|
||||
#define UART_Error_Break UART_RSR_BE_Msk /*!< Флаг разрыва линии */
|
||||
#define UART_Error_Overflow UART_RSR_OE_Msk /*!< Флаг переполнения буффера приемника */
|
||||
#define UART_Error_All (UART_RSR_FE_Msk | \
|
||||
UART_RSR_PE_Msk | \
|
||||
UART_RSR_BE_Msk | \
|
||||
UART_RSR_OE_Msk) /*!< Все флаги ошибок выбраны */
|
||||
|
||||
#define IS_UART_ERROR(VALUE) (((VALUE) & ~UART_Error_All) == 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define IS_UART_INT_DIV(VALUE) (((VALUE) > 0) && ((VALUE) < 0x10000))
|
||||
#define IS_UART_FRAC_DIV(VALUE) ((VALUE) < 0x40)
|
||||
#define IS_UART_DATA(VALUE) ((VALUE) < 0x100)
|
||||
|
||||
/**
|
||||
* @brief Выбор режима передачи стопового бита
|
||||
*/
|
||||
typedef enum {
|
||||
UART_StopBit_1, /*!< Один стоповый бит */
|
||||
UART_StopBit_2 /*!< Два стоповых бита */
|
||||
} UART_StopBit_TypeDef;
|
||||
#define IS_UART_STOP_BIT(VALUE) (((VALUE) == UART_StopBit_1) || \
|
||||
((VALUE) == UART_StopBit_2))
|
||||
|
||||
/**
|
||||
* @brief Выбор режима бита четности
|
||||
*/
|
||||
typedef enum {
|
||||
UART_ParityBit_Disable = 0, /*!< Не передается, не проверяется */
|
||||
UART_ParityBit_Odd = UART_LCRH_PEN_Msk, /*!< Проверка нечетности данных */
|
||||
UART_ParityBit_Even = UART_LCRH_PEN_Msk | UART_LCRH_EPS_Msk, /*!< Проверка четности данных */
|
||||
UART_ParityBit_High = UART_LCRH_PEN_Msk | UART_LCRH_SPS_Msk, /*!< Бит четности постоянно равен единице */
|
||||
UART_ParityBit_Low = UART_LCRH_PEN_Msk | UART_LCRH_SPS_Msk | UART_LCRH_EPS_Msk /*!< Бит четности постоянно равен нулю */
|
||||
} UART_ParityBit_TypeDef;
|
||||
#define IS_UART_PARITY_BIT(VALUE) (((VALUE) == UART_ParityBit_Disable) || \
|
||||
((VALUE) == UART_ParityBit_Odd) || \
|
||||
((VALUE) == UART_ParityBit_Even) || \
|
||||
((VALUE) == UART_ParityBit_High) || \
|
||||
((VALUE) == UART_ParityBit_Low))
|
||||
|
||||
/**
|
||||
* @brief Количество передаваемых/принимаемых информационных бит
|
||||
*/
|
||||
typedef enum {
|
||||
UART_DataWidth_5 = UART_LCRH_WLEN_5bit, /*!< Длина информационного слова 5 бит */
|
||||
UART_DataWidth_6 = UART_LCRH_WLEN_6bit, /*!< Длина информационного слова 6 бит */
|
||||
UART_DataWidth_7 = UART_LCRH_WLEN_7bit, /*!< Длина информационного слова 7 бит */
|
||||
UART_DataWidth_8 = UART_LCRH_WLEN_8bit /*!< Длина информационного слова 8 бит */
|
||||
} UART_DataWidth_TypeDef;
|
||||
#define IS_UART_DATA_WIDTH(VALUE) (((VALUE) == UART_DataWidth_5) || \
|
||||
((VALUE) == UART_DataWidth_6) || \
|
||||
((VALUE) == UART_DataWidth_7) || \
|
||||
((VALUE) == UART_DataWidth_8))
|
||||
|
||||
/**
|
||||
* @brief Порог заполнения/опустошения буфера приемника/передатчика, по достижению которого
|
||||
* будет генерироваться прерывание
|
||||
*/
|
||||
typedef enum {
|
||||
UART_FIFOLevel_1_8 = UART_IFLS_TXIFLSEL_Lvl18, /*!< Заполнение/опустошение FIFO на 1/8 */
|
||||
UART_FIFOLevel_1_4 = UART_IFLS_TXIFLSEL_Lvl14, /*!< Заполнение/опустошение FIFO на 1/4 */
|
||||
UART_FIFOLevel_1_2 = UART_IFLS_TXIFLSEL_Lvl12, /*!< Заполнение/опустошение FIFO на 1/2 */
|
||||
UART_FIFOLevel_3_4 = UART_IFLS_TXIFLSEL_Lvl34, /*!< Заполнение/опустошение FIFO на 3/4 */
|
||||
UART_FIFOLevel_7_8 = UART_IFLS_TXIFLSEL_Lvl78 /*!< Заполнение/опустошение FIFO на 7/8 */
|
||||
} UART_FIFOLevel_TypeDef;
|
||||
#define IS_UART_FIFO_LEVEL(VALUE) (((VALUE) == UART_FIFOLevel_1_8) || \
|
||||
((VALUE) == UART_FIFOLevel_1_4) || \
|
||||
((VALUE) == UART_FIFOLevel_1_2) || \
|
||||
((VALUE) == UART_FIFOLevel_3_4) || \
|
||||
((VALUE) == UART_FIFOLevel_7_8))
|
||||
|
||||
/**
|
||||
* @brief Структура инициализации UART
|
||||
*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
UART_StopBit_TypeDef StopBit; /*!< Выбор режима передачи стопового бита */
|
||||
UART_ParityBit_TypeDef ParityBit; /*!< Выбор режима бита четности */
|
||||
UART_DataWidth_TypeDef DataWidth; /*!< Количество передаваемых/принимаемых информационных бит */
|
||||
uint32_t BaudRate; /*!< Желаемая скорость передачи данных в бит/с */
|
||||
FunctionalState FIFO; /*!< Разрешение режима FIFO буфера приемника и передатчика */
|
||||
FunctionalState Rx; /*!< Разрешение приема */
|
||||
FunctionalState Tx; /*!< Разрешение передачи */
|
||||
} UART_Init_TypeDef;
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
void UART_AutoBaudConfig(UART_TypeDef* UARTx, uint32_t BaudRate);
|
||||
|
||||
/**
|
||||
* @brief Разрешение работы выбранного UART
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_Cmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->CR_bit.UARTEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка ширины слова данных
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param DataWidth Значение разрядности слова
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_DataWidthConfig(UART_TypeDef* UARTx, UART_DataWidth_TypeDef DataWidth)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_DATA_WIDTH(DataWidth));
|
||||
|
||||
WRITE_REG(UARTx->LCRH_bit.WLEN, DataWidth);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка количества стоп-бит
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param StopBit Количество стоп-бит
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_StopBitConfig(UART_TypeDef* UARTx, UART_StopBit_TypeDef StopBit)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_STOP_BIT(StopBit));
|
||||
|
||||
WRITE_REG(UARTx->LCRH_bit.STP2, StopBit);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима бита четности
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param ParityBit Режим
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ParityBitConfig(UART_TypeDef* UARTx, UART_ParityBit_TypeDef ParityBit)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_PARITY_BIT(ParityBit));
|
||||
|
||||
MODIFY_REG(UARTx->LCRH, UART_LCRH_PEN_Msk | UART_LCRH_SPS_Msk | UART_LCRH_EPS_Msk, ParityBit);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Ручная настройка делителя для реализации необходимой скорости передачи
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param IntDiv Целая часть делителя.
|
||||
* Параметр принимает любое значение из диапазона 1-65535.
|
||||
* @param FracDiv Дробная часть делителя.
|
||||
* Параметр принимает любое значение из диапазона 0-63. В случае, если IntDiv
|
||||
* равен 65535, значение FracDiv может быть только 0.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_BaudDivConfig(UART_TypeDef* UARTx, uint32_t IntDiv, uint32_t FracDiv)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_INT_DIV(IntDiv));
|
||||
assert_param(IS_UART_FRAC_DIV(FracDiv));
|
||||
|
||||
WRITE_REG(UARTx->IBRD, IntDiv);
|
||||
WRITE_REG(UARTx->FBRD, FracDiv);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение разрыва линии
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_BreakCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->LCRH_bit.BRK, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включение FIFO
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_FIFOCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->LCRH_bit.FEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение приема
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_RxCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->CR_bit.RXE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение передачи
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_TxCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->CR_bit.TXE, State);
|
||||
}
|
||||
|
||||
/** @defgroup UART_Init_Deinit Инициализация и деинициализация
|
||||
* @{
|
||||
*/
|
||||
|
||||
void UART_DeInit(UART_TypeDef* UARTx);
|
||||
void UART_Init(UART_TypeDef* UARTx, UART_Init_TypeDef* InitStruct);
|
||||
void UART_StructInit(UART_Init_TypeDef* InitStruct);
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_SendRecieve Прием и передача
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Передача слова данных
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param Data Слово данных (биты 7-0)
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_SendData(UART_TypeDef* UARTx, uint32_t Data)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_DATA(Data));
|
||||
|
||||
WRITE_REG(UARTx->DR, Data);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Прием слова данных
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @retval Val Слово данных
|
||||
*/
|
||||
__STATIC_INLINE uint32_t UART_RecieveData(UART_TypeDef* UARTx)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
|
||||
return READ_REG(UARTx->DR_bit.DATA);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос состояния выбранного флага
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param Flag Выбор флагов.
|
||||
* Параметр принимает любую совокупность значений UART_Flag_x из @ref UART_Flag_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus UART_FlagStatus(UART_TypeDef* UARTx, uint32_t Flag)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_FLAG(Flag));
|
||||
|
||||
return (FlagStatus)READ_BIT(UARTx->FR, Flag);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос состояния выбранного флага ошибки
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param Error Выбор флагов ошибки.
|
||||
* Параметр принимает любую совокупность значений UART_Error_x из @ref UART_Error_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько флагов,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus UART_ErrorStatus(UART_TypeDef* UARTx, uint32_t Error)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_ERROR(Error));
|
||||
|
||||
return (FlagStatus)READ_BIT(UARTx->RSR, Error);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Очистка флагов ошибки
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param Error Выбор флагов ошибки.
|
||||
* Параметр принимает любую совокупность значений UART_Error_x из @ref UART_Error_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ErrorStatusClear(UART_TypeDef* UARTx, uint32_t Error)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_ERROR(Error));
|
||||
|
||||
WRITE_REG(UARTx->RSR, Error);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_IT Прерывания
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка порога заполнения FIFO при приёме для генерации прерывания
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param FIFOLevelRx Порог
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ITFIFOLevelRxConfig(UART_TypeDef* UARTx, UART_FIFOLevel_TypeDef FIFOLevelRx)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_FIFO_LEVEL(FIFOLevelRx));
|
||||
|
||||
WRITE_REG(UARTx->IFLS_bit.RXIFLSEL, FIFOLevelRx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка порога опустошения FIFO при передаче для генерации прерывания
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param FIFOLevelTx Порог
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ITFIFOLevelTxConfig(UART_TypeDef* UARTx, UART_FIFOLevel_TypeDef FIFOLevelTx)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_FIFO_LEVEL(FIFOLevelTx));
|
||||
|
||||
WRITE_REG(UARTx->IFLS_bit.TXIFLSEL, FIFOLevelTx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Маскирование выбранных прерываний
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений UART_ITSource_x из @ref UART_ITSource_Define.
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ITCmd(UART_TypeDef* UARTx, uint32_t ITSource, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_IT_SOURCE(ITSource));
|
||||
|
||||
MODIFY_REG(UARTx->IMSC, ITSource, State ? ITSource : 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос немаскированного состояния прерывания
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений UART_ITSource_x из @ref UART_ITSource_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus UART_ITRawStatus(UART_TypeDef* UARTx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_IT_SOURCE(ITSource));
|
||||
|
||||
return (FlagStatus)READ_BIT(UARTx->RIS, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрос маскированного состояния прерывания
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений UART_ITSource_x из @ref UART_ITSource_Define.
|
||||
* @retval Status Состояние флага. Если выбрано несколько прерываний,
|
||||
* то результат соответсвует логическому ИЛИ их состояний.
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus UART_ITMaskedStatus(UART_TypeDef* UARTx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_IT_SOURCE(ITSource));
|
||||
|
||||
return (FlagStatus)READ_BIT(UARTx->MIS, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Сброс флагов состояния выбранных прерываний
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param ITSource Выбор прерываний.
|
||||
* Параметр принимает любую совокупность значений UART_ITSource_x из @ref UART_ITSource_Define.
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_ITStatusClear(UART_TypeDef* UARTx, uint32_t ITSource)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_UART_IT_SOURCE(ITSource));
|
||||
|
||||
WRITE_REG(UARTx->ICR, ITSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_DMA Настройка DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Управление блокированием запросов DMA от приемника в случае возникновения
|
||||
* прерывания по ошибке
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_DMABlkOnErrCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->DMACR_bit.DMAONERR, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение формирования запросов DMA для обслуживания буфера приемника
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_DMARxCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->DMACR_bit.RXDMAE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение формирования запросов DMA для обслуживания буфера передатчика
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void UART_DMATxCmd(UART_TypeDef* UARTx, FunctionalState State)
|
||||
{
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(UARTx->DMACR_bit.TXDMAE, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_UART_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
44
MDK-ARM/platform/plib035/inc/plib035_version.h
Normal file
44
MDK-ARM/platform/plib035/inc/plib035_version.h
Normal file
@@ -0,0 +1,44 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_version.h
|
||||
*
|
||||
* @brief Версия библиотеки
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __PLIB035_VERSION_H
|
||||
#define __PLIB035_VERSION_H
|
||||
|
||||
/* Полный номер версии библиотеки */
|
||||
#define PLIB035_VERSION 1.1.4
|
||||
|
||||
/* Основная версия библиотеки - увеличивается когда вносятся объемные глобальные изменения, ломающие обратную совместимость */
|
||||
#define PLIB035_VERSION_MAJOR 1
|
||||
|
||||
/* Минорная версия библиотеки - увеличивается когда добавляется функционал */
|
||||
#define PLIB035_VERSION_MINOR 1
|
||||
|
||||
/* Номер патча библиотеки - увеличивается когда правятся баги */
|
||||
#define PLIB035_VERSION_PATCH 4
|
||||
|
||||
#endif /* __PLIB035_VERSION_H */
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
191
MDK-ARM/platform/plib035/inc/plib035_wdt.h
Normal file
191
MDK-ARM/platform/plib035/inc/plib035_wdt.h
Normal file
@@ -0,0 +1,191 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_wdt.h
|
||||
*
|
||||
* @brief Файл содержит прототипы и компактные inline реализации функций для
|
||||
* WDT, а также сопутствующие макроопределения и перечисления
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Define to prevent recursive inclusion -------------------------------------*/
|
||||
#ifndef __PLIB035_WDT_H
|
||||
#define __PLIB035_WDT_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup WDT
|
||||
* @brief Драйвер для работы с WDT
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Exported_Defines Константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define WDT_LOCK_VAL 0xDEADC0DEUL /*!< Любое значение для блокировки записи в регистры таймера */
|
||||
#define WDT_UNLOCK_VAL 0x1ACCE551UL /*!< Значение для разблокировки записи в регистры таймера */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Exported_Types Типы
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define IS_WDT_LOAD(VALUE) ((VALUE) > 0)
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Exported_Functions Функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Разрешение счета сторожевого таймера и маскирование (включение) его прерывания
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void WDT_Cmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(WDT->CTRL_bit.INTEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка значения перезагрузки
|
||||
* @param LoadVal Значение перезагрузки (0x1 - 0xFFFFFFFF)
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void WDT_SetLoad(uint32_t LoadVal)
|
||||
{
|
||||
assert_param(IS_WDT_LOAD(LoadVal));
|
||||
|
||||
WRITE_REG(WDT->LOAD, LoadVal);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения перезагрузки
|
||||
* @retval Val Значение перезагрузки
|
||||
*/
|
||||
__STATIC_INLINE uint32_t WDT_GetLoad()
|
||||
{
|
||||
return READ_REG(WDT->LOAD);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения счетчика
|
||||
* @retval Val Значение счетчика
|
||||
*/
|
||||
__STATIC_INLINE uint32_t WDT_GetCounter()
|
||||
{
|
||||
return READ_REG(WDT->VALUE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Разрешение сброса по сторожевому таймеру.
|
||||
* Сброс будет произведен когда счетчик досчитает до нуля при установленном
|
||||
* ранее и несброшенном флаге прерывания
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void WDT_RstCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
WRITE_REG(WDT->CTRL_bit.RESEN, State);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запрещение записи во все регистры сторожевого таймера для
|
||||
* предотвращения его отключения сбойными программами
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void WDT_LockCmd(FunctionalState State)
|
||||
{
|
||||
assert_param(IS_FUNCTIONAL_STATE(State));
|
||||
|
||||
if (State == DISABLE) {
|
||||
WRITE_REG(WDT->LOCK, WDT_UNLOCK_VAL);
|
||||
} else {
|
||||
WRITE_REG(WDT->LOCK, WDT_LOCK_VAL);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение немаскированного флага прерывания сторожевого таймера
|
||||
* @retval Status Статус прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus WDT_ITRawStatus()
|
||||
{
|
||||
return (FlagStatus)READ_BIT(WDT->RIS, WDT_RIS_RAWWDTINT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Чтение маскированного флага прерывания сторожевого таймера
|
||||
* @retval Status Статус прерывания
|
||||
*/
|
||||
__STATIC_INLINE FlagStatus WDT_ITMaskedStatus()
|
||||
{
|
||||
return (FlagStatus)READ_BIT(WDT->MIS, WDT_MIS_WDTINT_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Очищение статусного бита прерывания сторожевого таймера
|
||||
* @retval void
|
||||
*/
|
||||
__STATIC_INLINE void WDT_ITStatusClear()
|
||||
{
|
||||
WRITE_REG(WDT->INTCLR, WDT_INTCLR_WDTCLR_Msk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __PLIB035_WDT_H */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
167
MDK-ARM/platform/plib035/src/plib035_adc.c
Normal file
167
MDK-ARM/platform/plib035/src/plib035_adc.c
Normal file
@@ -0,0 +1,167 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_adc.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с ADC
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_adc.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup ADC
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ADC_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры ADC значениями по умолчанию
|
||||
* @retval void
|
||||
*/
|
||||
void ADC_DeInit(void)
|
||||
{
|
||||
RCU_ADCRstCmd(DISABLE);
|
||||
RCU_ADCRstCmd(ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует секвенсоры АЦП согласно параметрам структуры InitStruct
|
||||
* @param SEQ_Num Выбор секвенсора
|
||||
* @param InitStruct Указатель на структуру типа @ref ADC_SEQ_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void ADC_SEQ_Init(ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
ADC_SEQ_StartEventConfig(SEQ_Num, InitStruct->StartEvent);
|
||||
ADC_SEQ_SwStartEnCmd(SEQ_Num, InitStruct->SWStartEn);
|
||||
for (uint32_t i = 0; i < ADC_SEQ_Req_Total; i++) {
|
||||
ADC_SEQ_ReqConfig(SEQ_Num, (ADC_SEQ_ReqNum_TypeDef)i, InitStruct->Req[i]);
|
||||
}
|
||||
ADC_SEQ_ReqMaxConfig(SEQ_Num, InitStruct->ReqMax);
|
||||
ADC_SEQ_ReqAverageConfig(SEQ_Num, InitStruct->ReqAverage);
|
||||
ADC_SEQ_ReqAverageCmd(SEQ_Num, InitStruct->ReqAverageEn);
|
||||
ADC_SEQ_RestartConfig(SEQ_Num, InitStruct->RestartCount);
|
||||
ADC_SEQ_RestartAverageCmd(SEQ_Num, InitStruct->RestartAverageEn);
|
||||
ADC_SEQ_SetRestartTimer(SEQ_Num, InitStruct->RestartTimer);
|
||||
for (uint32_t i = 0; i < ADC_DC_Total; i++) {
|
||||
ADC_SEQ_DCEnableCmd(SEQ_Num, (ADC_DC_Num_TypeDef)i, InitStruct->DCEn[i]);
|
||||
}
|
||||
ADC_SEQ_DMAConfig(SEQ_Num, InitStruct->DMAFIFOLevel);
|
||||
ADC_SEQ_DMACmd(SEQ_Num, InitStruct->DMAEn);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref ADC_SEQ_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void ADC_SEQ_StructInit(ADC_SEQ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->StartEvent = ADC_SEQ_StartEvent_SwReq;
|
||||
InitStruct->SWStartEn = DISABLE;
|
||||
for (uint32_t i = 0; i < ADC_SEQ_Req_Total; i++) {
|
||||
InitStruct->Req[i] = ADC_CH_Num_0;
|
||||
}
|
||||
InitStruct->ReqMax = ADC_SEQ_ReqNum_0;
|
||||
InitStruct->ReqAverage = ADC_SEQ_Average_2;
|
||||
InitStruct->ReqAverageEn = DISABLE;
|
||||
InitStruct->RestartCount = 0;
|
||||
InitStruct->RestartAverageEn = DISABLE;
|
||||
InitStruct->RestartTimer = 0;
|
||||
for (uint32_t i = 0; i < ADC_DC_Total; i++) {
|
||||
InitStruct->DCEn[i] = DISABLE;
|
||||
}
|
||||
InitStruct->DMAFIFOLevel = ADC_SEQ_DMAFIFOLevel_1;
|
||||
InitStruct->DMAEn = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует цифровые компараторы АЦП согласно параметрам структуры InitStruct
|
||||
* @param DC_Num Выбор компаратора
|
||||
* @param InitStruct Указатель на структуру типа @ref ADC_DC_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void ADC_DC_Init(ADC_DC_Num_TypeDef DC_Num, ADC_DC_Init_TypeDef* InitStruct)
|
||||
{
|
||||
ADC_DC_OutputCmd(DC_Num, InitStruct->DCOutput);
|
||||
ADC_DC_SetThresholdLow(DC_Num, InitStruct->ThresholdLow);
|
||||
ADC_DC_SetThresholdHigh(DC_Num, InitStruct->ThresholdHigh);
|
||||
ADC_DC_SourceConfig(DC_Num, InitStruct->Source);
|
||||
ADC_DC_ChannelConfig(DC_Num, InitStruct->Channel);
|
||||
ADC_DC_Config(DC_Num, InitStruct->Mode, InitStruct->Condition);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref ADC_DC_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void ADC_DC_StructInit(ADC_DC_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->DCOutput = DISABLE;
|
||||
InitStruct->ThresholdLow = 0;
|
||||
InitStruct->ThresholdHigh = 0;
|
||||
InitStruct->Source = ADC_DC_Source_EOC;
|
||||
InitStruct->Channel = ADC_CH_Num_0;
|
||||
InitStruct->Mode = ADC_DC_Mode_Multiple;
|
||||
InitStruct->Condition = ADC_DC_Condition_Low;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
70
MDK-ARM/platform/plib035/src/plib035_can.c
Normal file
70
MDK-ARM/platform/plib035/src/plib035_can.c
Normal file
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_can.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с CAN
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_can.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup CAN
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup CAN_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
209
MDK-ARM/platform/plib035/src/plib035_dma.c
Normal file
209
MDK-ARM/platform/plib035/src/plib035_dma.c
Normal file
@@ -0,0 +1,209 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_dma.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с DMA
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_dma.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup DMA
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup DMA_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Деинициализация канала DMA
|
||||
* @param ChannelStruct Указатель на структуру типа @ref DMA_Channel_TypeDef,
|
||||
* которая содержит конфигурационную информацию канала
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_ChannelDeInit(DMA_Channel_TypeDef* ChannelStruct)
|
||||
{
|
||||
ChannelStruct->SRC_DATA_END_PTR = 0;
|
||||
ChannelStruct->DST_DATA_END_PTR = 0;
|
||||
ChannelStruct->CHANNEL_CFG = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализация канала DMA
|
||||
* @param ChannelStruct Непосредственно сама структура канала
|
||||
* @param ChannelInitStruct Указатель на структуру типа @ref DMA_ChannelInit_TypeDef,
|
||||
* которая содержит конфигурационную информацию канала
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_ChannelInit(DMA_Channel_TypeDef* ChannelStruct, DMA_ChannelInit_TypeDef* ChannelInitStruct)
|
||||
{
|
||||
assert_param(IS_DMA_MODE(ChannelInitStruct->Mode));
|
||||
assert_param(IS_DMA_ARBITRATION_RATE(ChannelInitStruct->ArbitrationRate));
|
||||
assert_param(IS_DMA_DATA_INC(ChannelInitStruct->DstDataInc));
|
||||
assert_param(IS_DMA_DATA_INC(ChannelInitStruct->SrcDataInc));
|
||||
assert_param(IS_DMA_DATA_SIZE(ChannelInitStruct->DstDataSize));
|
||||
assert_param(IS_DMA_DATA_SIZE(ChannelInitStruct->SrcDataSize));
|
||||
assert_param(IS_DMA_TRANSFERS_TOTAL(ChannelInitStruct->TransfersTotal));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->DstProtect.Bufferable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->DstProtect.Cacheable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->DstProtect.Priveleged));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->SrcProtect.Bufferable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->SrcProtect.Cacheable));
|
||||
assert_param(IS_FUNCTIONAL_STATE(ChannelInitStruct->SrcProtect.Priveleged));
|
||||
|
||||
/* источник */
|
||||
ChannelStruct->SRC_DATA_END_PTR = (uint32_t)ChannelInitStruct->SrcDataEndPtr;
|
||||
ChannelStruct->CHANNEL_CFG_bit.SRC_SIZE = ChannelInitStruct->SrcDataSize;
|
||||
ChannelStruct->CHANNEL_CFG_bit.SRC_INC = ChannelInitStruct->SrcDataInc;
|
||||
ChannelStruct->CHANNEL_CFG_bit.SRC_PROT_BUFF = ChannelInitStruct->SrcProtect.Bufferable;
|
||||
ChannelStruct->CHANNEL_CFG_bit.SRC_PROT_PRIV = ChannelInitStruct->SrcProtect.Priveleged;
|
||||
ChannelStruct->CHANNEL_CFG_bit.SRC_PROT_CACHE = ChannelInitStruct->SrcProtect.Cacheable;
|
||||
/* приемник */
|
||||
ChannelStruct->DST_DATA_END_PTR = (uint32_t)ChannelInitStruct->DstDataEndPtr;
|
||||
ChannelStruct->CHANNEL_CFG_bit.DST_SIZE = ChannelInitStruct->DstDataSize;
|
||||
ChannelStruct->CHANNEL_CFG_bit.DST_INC = ChannelInitStruct->DstDataInc;
|
||||
ChannelStruct->CHANNEL_CFG_bit.DST_PROT_BUFF = ChannelInitStruct->DstProtect.Bufferable;
|
||||
ChannelStruct->CHANNEL_CFG_bit.DST_PROT_PRIV = ChannelInitStruct->DstProtect.Priveleged;
|
||||
ChannelStruct->CHANNEL_CFG_bit.DST_PROT_CACHE = ChannelInitStruct->DstProtect.Cacheable;
|
||||
/* общее */
|
||||
ChannelStruct->CHANNEL_CFG_bit.NEXT_USEBURST = ChannelInitStruct->NextUseburst;
|
||||
ChannelStruct->CHANNEL_CFG_bit.R_POWER = ChannelInitStruct->ArbitrationRate;
|
||||
ChannelStruct->CHANNEL_CFG_bit.N_MINUS_1 = ChannelInitStruct->TransfersTotal - 1;
|
||||
ChannelStruct->CHANNEL_CFG_bit.CYCLE_CTRL = ChannelInitStruct->Mode;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры ChannelInitStruct значениями по умолчанию
|
||||
* @param ChannelInitStruct Указатель на структуру типа @ref DMA_ChannelInit_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_ChannelStructInit(DMA_ChannelInit_TypeDef* ChannelInitStruct)
|
||||
{
|
||||
/* источник */
|
||||
ChannelInitStruct->SrcDataEndPtr = (uint32_t*)0x00000000;
|
||||
ChannelInitStruct->SrcDataSize = DMA_DataSize_8;
|
||||
ChannelInitStruct->SrcDataInc = DMA_DataInc_Disable;
|
||||
ChannelInitStruct->SrcProtect.Bufferable = DISABLE;
|
||||
ChannelInitStruct->SrcProtect.Priveleged = DISABLE;
|
||||
ChannelInitStruct->SrcProtect.Cacheable = DISABLE;
|
||||
/* приемник */
|
||||
ChannelInitStruct->DstDataEndPtr = (uint32_t*)0x00000000;
|
||||
ChannelInitStruct->DstDataSize = DMA_DataSize_8;
|
||||
ChannelInitStruct->DstDataInc = DMA_DataInc_Disable;
|
||||
ChannelInitStruct->DstProtect.Bufferable = DISABLE;
|
||||
ChannelInitStruct->DstProtect.Priveleged = DISABLE;
|
||||
ChannelInitStruct->DstProtect.Cacheable = DISABLE;
|
||||
/* общее */
|
||||
ChannelInitStruct->NextUseburst = DISABLE;
|
||||
ChannelInitStruct->ArbitrationRate = DMA_ArbitrationRate_1;
|
||||
ChannelInitStruct->TransfersTotal = 1;
|
||||
ChannelInitStruct->Mode = DMA_Mode_Disable;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Деинициализация контроллера DMA
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_DeInit()
|
||||
{
|
||||
CLEAR_REG(DMA->CFG);
|
||||
CLEAR_REG(DMA->BASEPTR);
|
||||
WRITE_REG(DMA->ENCLR, DMA_Channel_All);
|
||||
WRITE_REG(DMA->PRIORITYCLR, DMA_Channel_All);
|
||||
WRITE_REG(DMA->PRIALTCLR, DMA_Channel_All);
|
||||
WRITE_REG(DMA->REQMASKCLR, DMA_Channel_All);
|
||||
WRITE_REG(DMA->USEBURSTCLR, DMA_Channel_All);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализация контроллера DMA
|
||||
* @attention Прежде чем инициализировать DMA, необходимо проинициализоровать каналы
|
||||
* с помощью @ref DMA_ChannelInit и сконфигурировать базовый адрес управляющей структуры
|
||||
* с помощью @ref DMA_BasePtrConfig
|
||||
* @param InitStruct Указатель на структуру типа @ref DMA_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_Init(DMA_Init_TypeDef* InitStruct)
|
||||
{
|
||||
DMA_ProtectConfig(&(InitStruct->CtrlProtect));
|
||||
DMA_UseBurstCmd(InitStruct->Channel, InitStruct->UseBurst);
|
||||
DMA_AltCtrlCmd(InitStruct->Channel, InitStruct->AltCtrl);
|
||||
DMA_HighPriorityCmd(InitStruct->Channel, InitStruct->HighPriority);
|
||||
DMA_ReqMaskCmd(InitStruct->Channel, InitStruct->ReqMask);
|
||||
DMA_ChannelEnableCmd(InitStruct->Channel, InitStruct->ChannelEnable);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры DMA_InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref DMA_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void DMA_StructInit(DMA_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Channel = DMA_Channel_All;
|
||||
InitStruct->ChannelEnable = DISABLE;
|
||||
InitStruct->HighPriority = DISABLE;
|
||||
InitStruct->AltCtrl = DISABLE;
|
||||
InitStruct->ReqMask = DISABLE;
|
||||
InitStruct->UseBurst = DISABLE;
|
||||
InitStruct->CtrlProtect.Bufferable = DISABLE;
|
||||
InitStruct->CtrlProtect.Cacheable = DISABLE;
|
||||
InitStruct->CtrlProtect.Priveleged = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
191
MDK-ARM/platform/plib035/src/plib035_ecap.c
Normal file
191
MDK-ARM/platform/plib035/src/plib035_ecap.c
Normal file
@@ -0,0 +1,191 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_ecap.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с ECAP
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_ecap.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup ECAP
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup ECAP_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры блока захвата значениями по умолчанию
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_DeInit(ECAP_TypeDef* ECAPx)
|
||||
{
|
||||
uint32_t ECAP_rst;
|
||||
|
||||
assert_param(IS_ECAP_PERIPH(ECAPx));
|
||||
|
||||
if (ECAPx == ECAP0)
|
||||
ECAP_rst = RCU_APBRst_ECAP0;
|
||||
else if (ECAPx == ECAP1)
|
||||
ECAP_rst = RCU_APBRst_ECAP1;
|
||||
else /* (ECAPx == ECAP2) */
|
||||
ECAP_rst = RCU_APBRst_ECAP2;
|
||||
|
||||
RCU_APBRstCmd(ECAP_rst, DISABLE);
|
||||
RCU_APBRstCmd(ECAP_rst, ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует ECAPx согласно параметрам структуры InitStruct.
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_Init(ECAP_TypeDef* ECAPx, ECAP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
ECAP_HaltConfig(ECAPx, InitStruct->Halt);
|
||||
ECAP_SyncOutConfig(ECAPx, InitStruct->SyncOut);
|
||||
ECAP_SyncCmd(ECAPx, InitStruct->SyncEn);
|
||||
ECAP_ModeConfig(ECAPx, InitStruct->Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_StructInit(ECAP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Halt = ECAP_Halt_Stop;
|
||||
InitStruct->Mode = ECAP_Mode_Capture;
|
||||
InitStruct->SyncEn = DISABLE;
|
||||
InitStruct->SyncOut = ECAP_SyncOut_Bypass;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует режим ШИМ блока ECAPx согласно параметрам структуры InitStruct.
|
||||
* @param ECAPx Выбор модуля CAP, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_PWM_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_PWM_Init(ECAP_TypeDef* ECAPx, ECAP_PWM_Init_TypeDef* InitStruct)
|
||||
{
|
||||
ECAP_PWM_SetPeriod(ECAPx, InitStruct->Period);
|
||||
ECAP_PWM_SetCompare(ECAPx, InitStruct->Compare);
|
||||
ECAP_PWM_PolarityConfig(ECAPx, InitStruct->Polarity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию.
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_PWM_Init_TypeDef,
|
||||
* которую необходимо проинициализировать.
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_PWM_StructInit(ECAP_PWM_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Period = 0xFFFFFFFF;
|
||||
InitStruct->Compare = 0x00010000;
|
||||
InitStruct->Polarity = ECAP_PWM_Polarity_Pos;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует режим захвата блока ECAPx согласно параметрам структуры InitStruct.
|
||||
* @param ECAPx Выбор модуля ECAP, где x лежит в диапазоне 0-5
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_Capture_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию.
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_Capture_Init(ECAP_TypeDef* ECAPx, ECAP_Capture_Init_TypeDef* InitStruct)
|
||||
{
|
||||
ECAP_Capture_ModeConfig(ECAPx, InitStruct->Mode);
|
||||
ECAP_Capture_StopConfig(ECAPx, InitStruct->StopVal);
|
||||
ECAP_Capture_PrescaleConfig(ECAPx, InitStruct->Prescale);
|
||||
ECAP_Capture_PolarityEvt0Config(ECAPx, InitStruct->PolarityEvt0);
|
||||
ECAP_Capture_PolarityEvt1Config(ECAPx, InitStruct->PolarityEvt1);
|
||||
ECAP_Capture_PolarityEvt2Config(ECAPx, InitStruct->PolarityEvt2);
|
||||
ECAP_Capture_PolarityEvt3Config(ECAPx, InitStruct->PolarityEvt3);
|
||||
ECAP_Capture_RstEvt0Cmd(ECAPx, InitStruct->RstEvt0);
|
||||
ECAP_Capture_RstEvt1Cmd(ECAPx, InitStruct->RstEvt1);
|
||||
ECAP_Capture_RstEvt2Cmd(ECAPx, InitStruct->RstEvt2);
|
||||
ECAP_Capture_RstEvt3Cmd(ECAPx, InitStruct->RstEvt3);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию.
|
||||
* @param InitStruct Указатель на структуру типа @ref ECAP_Capture_Init_TypeDef,
|
||||
* которую необходимо проинициализировать.
|
||||
* @retval void
|
||||
*/
|
||||
void ECAP_Capture_StructInit(ECAP_Capture_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Mode = ECAP_Capture_Mode_Single;
|
||||
InitStruct->StopVal = 0;
|
||||
InitStruct->Prescale = 0;
|
||||
InitStruct->PolarityEvt0 = ECAP_Capture_Polarity_PosEdge;
|
||||
InitStruct->PolarityEvt1 = ECAP_Capture_Polarity_PosEdge;
|
||||
InitStruct->PolarityEvt2 = ECAP_Capture_Polarity_PosEdge;
|
||||
InitStruct->PolarityEvt3 = ECAP_Capture_Polarity_PosEdge;
|
||||
InitStruct->RstEvt0 = DISABLE;
|
||||
InitStruct->RstEvt1 = DISABLE;
|
||||
InitStruct->RstEvt2 = DISABLE;
|
||||
InitStruct->RstEvt3 = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
212
MDK-ARM/platform/plib035/src/plib035_gpio.c
Normal file
212
MDK-ARM/platform/plib035/src/plib035_gpio.c
Normal file
@@ -0,0 +1,212 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_gpio.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с GPIO
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_gpio.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup GPIO
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup GPIO_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Записывает необходимое 2-битное значение режима в регистр порта для всех выбранных пинов
|
||||
* @param Reg Указатель на изменяемый регистр
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param Val Конфигурация пинов (2-битное значение)
|
||||
* @retval void
|
||||
*/
|
||||
static void GPIO_ModeConfig(volatile uint32_t* Reg, uint32_t Pin, uint32_t Val)
|
||||
{
|
||||
uint32_t reg_temp = *Reg;
|
||||
|
||||
for (uint32_t i = 0; i < 16; i++) {
|
||||
if (Pin & (1 << i)) {
|
||||
reg_temp &= ~(0x3UL << i * 0x2UL);
|
||||
reg_temp |= Val << i * 0x2UL;
|
||||
}
|
||||
}
|
||||
|
||||
*Reg = reg_temp;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима работы выходного каскада
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param OutMode Режим работы
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_OutModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_OutMode_TypeDef OutMode)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_OUT_MODE(OutMode));
|
||||
|
||||
GPIO_ModeConfig(&(GPIOx->OUTMODE), Pin, (uint32_t)OutMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима работы входа
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param InMode Режим работы
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_InModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_InMode_TypeDef InMode)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_IN_MODE(InMode));
|
||||
|
||||
GPIO_ModeConfig(&(GPIOx->INMODE), Pin, (uint32_t)InMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка режима работы подтяжек пинов
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param PullMode Режим работы
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_PullModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_PullMode_TypeDef PullMode)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_PULL_MODE(PullMode));
|
||||
|
||||
GPIO_ModeConfig(&(GPIOx->PULLMODE), Pin, (uint32_t)PullMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка нагрузочной способности и скорости переключения пинов
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param Pin Выбор пинов. Любая совокупность значений GPIO_Pin_x (@ref GPIO_Pin_Define).
|
||||
* @param DriveMode Режим работы
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_DriveModeConfig(GPIO_TypeDef* GPIOx, uint32_t Pin, GPIO_DriveMode_TypeDef DriveMode)
|
||||
{
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
assert_param(IS_GPIO_PIN(Pin));
|
||||
assert_param(IS_GPIO_DRIVE_MODE(DriveMode));
|
||||
|
||||
GPIO_ModeConfig(&(GPIOx->DRIVEMODE), Pin, (uint32_t)DriveMode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры выбранного GPIOx значениями по умолчанию
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_DeInit(GPIO_TypeDef* GPIOx)
|
||||
{
|
||||
uint32_t GPIO_rst;
|
||||
|
||||
assert_param(IS_GPIO_PERIPH(GPIOx));
|
||||
|
||||
if (GPIOx == GPIOA)
|
||||
GPIO_rst = RCU_AHBRst_GPIOA;
|
||||
else /* (GPIOx == GPIOB) */
|
||||
GPIO_rst = RCU_AHBRst_GPIOB;
|
||||
|
||||
RCU_AHBRstCmd(GPIO_rst, DISABLE);
|
||||
RCU_AHBRstCmd(GPIO_rst, ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует модуль GPIOx согласно параметрам структуры InitStruct.
|
||||
* Порт не начнет функционировать, пока не будет разрешена цифровая работа пина @ref GPIO_DigitalCmd .
|
||||
* @param GPIOx Выбор порта, где x=A|B
|
||||
* @param InitStruct Указатель на структуру типа @ref GPIO_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_Init_TypeDef* InitStruct)
|
||||
{
|
||||
GPIO_OutCmd(GPIOx, InitStruct->Pin, InitStruct->Out);
|
||||
GPIO_AltFuncCmd(GPIOx, InitStruct->Pin, InitStruct->AltFunc);
|
||||
GPIO_OutModeConfig(GPIOx, InitStruct->Pin, InitStruct->OutMode);
|
||||
GPIO_InModeConfig(GPIOx, InitStruct->Pin, InitStruct->InMode);
|
||||
GPIO_PullModeConfig(GPIOx, InitStruct->Pin, InitStruct->PullMode);
|
||||
GPIO_DriveModeConfig(GPIOx, InitStruct->Pin, InitStruct->DriveMode);
|
||||
GPIO_DigitalCmd(GPIOx, InitStruct->Pin, InitStruct->Digital);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref GPIO_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void GPIO_StructInit(GPIO_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Pin = GPIO_Pin_All;
|
||||
InitStruct->Out = DISABLE;
|
||||
InitStruct->AltFunc = DISABLE;
|
||||
InitStruct->OutMode = GPIO_OutMode_PP;
|
||||
InitStruct->InMode = GPIO_InMode_Schmitt;
|
||||
InitStruct->PullMode = GPIO_PullMode_Disable;
|
||||
InitStruct->DriveMode = GPIO_DriveMode_HighFast;
|
||||
InitStruct->Digital = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
98
MDK-ARM/platform/plib035/src/plib035_i2c.c
Normal file
98
MDK-ARM/platform/plib035/src/plib035_i2c.c
Normal file
@@ -0,0 +1,98 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_i2c.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с I2C
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_i2c.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup I2C
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup I2C_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка частоты SCL врежиме FS
|
||||
* @param FSFreq Желаемое значение частоты в ГЦ
|
||||
* @param I2CFreq Значение частоты тактового сигнала I2C в ГЦ
|
||||
* @retval void
|
||||
*/
|
||||
void I2C_FSFreqConfig(uint32_t FSFreq, uint32_t I2CFreq)
|
||||
{
|
||||
uint32_t freq_calc = I2CFreq / (4 * FSFreq);
|
||||
|
||||
I2C_FSDivLowConfig(freq_calc & 0x7F);
|
||||
I2C_FSDivHighConfig(freq_calc >> 7);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка частоты SCL врежиме HS
|
||||
* @param HSFreq Желаемое значение частоты в ГЦ
|
||||
* @param I2CFreq Значение частоты тактового сигнала I2C в ГЦ
|
||||
* @retval void
|
||||
*/
|
||||
void I2C_HSFreqConfig(uint32_t HSFreq, uint32_t I2CFreq)
|
||||
{
|
||||
uint32_t freq_calc = I2CFreq / (3 * HSFreq);
|
||||
|
||||
I2C_HSDivLowConfig(freq_calc & 0x0F);
|
||||
I2C_HSDivHighConfig(freq_calc >> 4);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
163
MDK-ARM/platform/plib035/src/plib035_mflash.c
Normal file
163
MDK-ARM/platform/plib035/src/plib035_mflash.c
Normal file
@@ -0,0 +1,163 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_mflash.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с MFLASH
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_mflash.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup MFLASH
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Private_Defines Приватные определения
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define __NOP5() \
|
||||
__NOP(); \
|
||||
__NOP(); \
|
||||
__NOP(); \
|
||||
__NOP(); \
|
||||
__NOP()
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup MFLASH_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Чтение информации из выбранной области флеш, начиная с указанного адреса
|
||||
* @param AddrVal Стартовый адрес
|
||||
* @param DataArr Указатель на массив, в который будут переданы 2 32-битных слова данных
|
||||
* @param Region Выбор области
|
||||
* @retval void
|
||||
*/
|
||||
void MFLASH_ReadData(uint32_t AddrVal, uint32_t* DataArr, MFLASH_Region_TypeDef Region)
|
||||
{
|
||||
assert_param(IS_MFLASH_REGION(Region));
|
||||
if (Region == MFLASH_Region_Main)
|
||||
assert_param(IS_MFLASH_MAIN_ADDR(AddrVal));
|
||||
else /* (Region == MFLASH_Region_NVR) */
|
||||
assert_param(IS_MFLASH_NVR_ADDR(AddrVal));
|
||||
|
||||
MFLASH_SetAddr(AddrVal);
|
||||
MFLASH_SetCmd(MFLASH_Cmd_Read, Region);
|
||||
__NOP5();
|
||||
while (MFLASH_BusyStatus()) {
|
||||
};
|
||||
for (uint32_t i = 0; i < MEM_MFLASH_BUS_WIDTH_WORDS; i++) {
|
||||
DataArr[i] = MFLASH_GetData(i);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Запись информации в выбранную область флеш, начиная с указанного адреса
|
||||
* @param AddrVal Стартовый адрес
|
||||
* @param DataArr Указатель на массив, из которого будут взяты 2 32-битных слова данных
|
||||
* @param Region Выбор области
|
||||
* @retval void
|
||||
*/
|
||||
void MFLASH_WriteData(uint32_t AddrVal, uint32_t* DataArr, MFLASH_Region_TypeDef Region)
|
||||
{
|
||||
assert_param(IS_MFLASH_REGION(Region));
|
||||
if (Region == MFLASH_Region_Main)
|
||||
assert_param(IS_MFLASH_MAIN_ADDR(AddrVal));
|
||||
else /* (Region == MFLASH_Region_NVR) */
|
||||
assert_param(IS_MFLASH_NVR_ADDR(AddrVal));
|
||||
|
||||
MFLASH_SetAddr(AddrVal);
|
||||
for (uint32_t i = 0; i < MEM_MFLASH_BUS_WIDTH_WORDS; i++) {
|
||||
MFLASH_SetData(i, DataArr[i]);
|
||||
}
|
||||
MFLASH_SetCmd(MFLASH_Cmd_Write, Region);
|
||||
__NOP5();
|
||||
while (MFLASH_BusyStatus()) {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Стирание выбранной страницы флеш
|
||||
* @param AddrVal Начальный адрес страницы
|
||||
* @param Region Выбор области
|
||||
* @retval void
|
||||
*/
|
||||
void MFLASH_ErasePage(uint32_t AddrVal, MFLASH_Region_TypeDef Region)
|
||||
{
|
||||
assert_param(IS_MFLASH_REGION(Region));
|
||||
if (Region == MFLASH_Region_Main)
|
||||
assert_param(IS_MFLASH_MAIN_ADDR(AddrVal));
|
||||
else /* (Region == MFLASH_Region_NVR) */
|
||||
assert_param(IS_MFLASH_NVR_ADDR(AddrVal));
|
||||
|
||||
MFLASH_SetAddr(AddrVal);
|
||||
MFLASH_SetCmd(MFLASH_Cmd_ErasePage, Region);
|
||||
__NOP5();
|
||||
while (MFLASH_BusyStatus()) {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Стирание области флеш полностью
|
||||
* @param Region Выбор области
|
||||
* @retval void
|
||||
*/
|
||||
void MFLASH_EraseFull(MFLASH_Region_TypeDef Region)
|
||||
{
|
||||
assert_param(IS_MFLASH_REGION(Region));
|
||||
|
||||
MFLASH_SetCmd(MFLASH_Cmd_EraseFull, Region);
|
||||
__NOP5();
|
||||
while (MFLASH_BusyStatus()) {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
70
MDK-ARM/platform/plib035/src/plib035_pmu.c
Normal file
70
MDK-ARM/platform/plib035/src/plib035_pmu.c
Normal file
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_pmu.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с PMU
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_pmu.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup PMU
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PMU_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
346
MDK-ARM/platform/plib035/src/plib035_pwm.c
Normal file
346
MDK-ARM/platform/plib035/src/plib035_pwm.c
Normal file
@@ -0,0 +1,346 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_pwm.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с PWM
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_pwm.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup PWM
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup PWM_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры PWM значениями по умолчанию
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_DeInit(PWM_TypeDef* PWMx)
|
||||
{
|
||||
uint32_t PWM_rst;
|
||||
|
||||
assert_param(IS_PWM_PERIPH(PWMx));
|
||||
|
||||
if (PWMx == PWM0)
|
||||
PWM_rst = RCU_APBRst_PWM0;
|
||||
else if (PWMx == PWM1)
|
||||
PWM_rst = RCU_APBRst_PWM1;
|
||||
else /* (PWMx == PWM2) */
|
||||
PWM_rst = RCU_APBRst_PWM2;
|
||||
|
||||
RCU_APBRstCmd(PWM_rst, DISABLE);
|
||||
RCU_APBRstCmd(PWM_rst, ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует таймер PWMx согласно параметрам структуры InitStruct
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_TB_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_TB_Init(PWM_TypeDef* PWMx, PWM_TB_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_TB_HaltConfig(PWMx, InitStruct->Halt);
|
||||
PWM_TB_PhaseSyncCmd(PWMx, InitStruct->PhaseSync);
|
||||
PWM_TB_PhaseSyncDirConfig(PWMx, InitStruct->PhaseSyncDir);
|
||||
PWM_TB_ClkDivConfig(PWMx, InitStruct->ClkDiv, InitStruct->ClkDivExtra);
|
||||
PWM_TB_SyncOutConfig(PWMx, InitStruct->SyncOut);
|
||||
PWM_TB_PeriodDirectLoadCmd(PWMx, InitStruct->PeriodDirectLoad);
|
||||
PWM_TB_ModeConfig(PWMx, InitStruct->Mode);
|
||||
PWM_TB_SetPhase(PWMx, InitStruct->Phase);
|
||||
PWM_TB_SetPeriod(PWMx, InitStruct->Period);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_TB_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_TB_StructInit(PWM_TB_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->ClkDiv = PWM_TB_ClkDiv_1;
|
||||
InitStruct->ClkDivExtra = PWM_TB_ClkDivExtra_1;
|
||||
InitStruct->Mode = PWM_TB_Mode_Up;
|
||||
InitStruct->Halt = PWM_TB_Halt_StopOnTBCLK;
|
||||
InitStruct->PeriodDirectLoad = DISABLE;
|
||||
InitStruct->PhaseSync = DISABLE;
|
||||
InitStruct->PhaseSyncDir = PWM_TB_Dir_Down;
|
||||
InitStruct->SyncOut = PWM_TB_SyncOut_SyncIn;
|
||||
InitStruct->Phase = 0;
|
||||
InitStruct->Period = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует действия на выводах PWMx согласно параметрам структуры InitStruct
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_AQ_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_AQ_Init(PWM_TypeDef* PWMx, PWM_AQ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqZero, InitStruct->ActionA_CTREqZero);
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqPeriod, InitStruct->ActionA_CTREqPeriod);
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqCMPAUp, InitStruct->ActionA_CTREqCMPAUp);
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqCMPADown, InitStruct->ActionA_CTREqCMPADown);
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqCMPBUp, InitStruct->ActionA_CTREqCMPBUp);
|
||||
PWM_AQ_ActionAConfig(PWMx, PWM_AQ_Event_CTREqCMPBDown, InitStruct->ActionA_CTREqCMPBDown);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqZero, InitStruct->ActionB_CTREqZero);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqPeriod, InitStruct->ActionB_CTREqPeriod);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqCMPAUp, InitStruct->ActionB_CTREqCMPAUp);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqCMPADown, InitStruct->ActionB_CTREqCMPADown);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqCMPBUp, InitStruct->ActionB_CTREqCMPBUp);
|
||||
PWM_AQ_ActionBConfig(PWMx, PWM_AQ_Event_CTREqCMPBDown, InitStruct->ActionB_CTREqCMPBDown);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_AQ_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_AQ_StructInit(PWM_AQ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->ActionA_CTREqZero = PWM_AQ_Action_None;
|
||||
InitStruct->ActionA_CTREqPeriod = PWM_AQ_Action_None;
|
||||
InitStruct->ActionA_CTREqCMPAUp = PWM_AQ_Action_None;
|
||||
InitStruct->ActionA_CTREqCMPADown = PWM_AQ_Action_None;
|
||||
InitStruct->ActionA_CTREqCMPBUp = PWM_AQ_Action_None;
|
||||
InitStruct->ActionA_CTREqCMPBDown = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqZero = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqPeriod = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqCMPAUp = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqCMPADown = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqCMPBUp = PWM_AQ_Action_None;
|
||||
InitStruct->ActionB_CTREqCMPBDown = PWM_AQ_Action_None;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует компараторы PWMx согласно параметрам структуры PWM_CMP_Init_TypeDef
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_CMP_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_CMP_Init(PWM_TypeDef* PWMx, PWM_CMP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_CMP_CmpALoadEventConfig(PWMx, InitStruct->LoadEventCmpA);
|
||||
PWM_CMP_CmpADirectLoadCmd(PWMx, InitStruct->CmpADirectLoad);
|
||||
PWM_CMP_SetCmpA(PWMx, InitStruct->CmpA);
|
||||
PWM_CMP_CmpALoadEventConfig(PWMx, InitStruct->LoadEventCmpB);
|
||||
PWM_CMP_CmpADirectLoadCmd(PWMx, InitStruct->CmpBDirectLoad);
|
||||
PWM_CMP_SetCmpB(PWMx, InitStruct->CmpB);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_CMPInit_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_CMP_StructInit(PWM_CMP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->LoadEventCmpA = PWM_CMP_LoadEvent_CTREqZero;
|
||||
InitStruct->CmpADirectLoad = DISABLE;
|
||||
InitStruct->CmpA = 0;
|
||||
InitStruct->LoadEventCmpB = PWM_CMP_LoadEvent_CTREqZero;
|
||||
InitStruct->CmpBDirectLoad = DISABLE;
|
||||
InitStruct->CmpB = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует пороговый выключатель PWMx согласно параметрам структуры PWM_HD_Init_TypeDef
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_HD_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_HD_Init(PWM_TypeDef* PWMx, PWM_HD_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_HD_ActionAConfig(PWMx, InitStruct->ActionA);
|
||||
PWM_HD_ActionBConfig(PWMx, InitStruct->ActionB);
|
||||
PWM_HD_SourceCmd(PWMx, InitStruct->Source, ENABLE);
|
||||
PWM_HD_CycleCmd(PWMx, InitStruct->Cycle);
|
||||
PWM_HD_OneShotCmd(PWMx, InitStruct->OneShot);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_HD_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_HD_StructInit(PWM_HD_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->ActionA = PWM_HD_Action_ToOne;
|
||||
InitStruct->ActionB = PWM_HD_Action_ToOne;
|
||||
InitStruct->Source = 0;
|
||||
InitStruct->Cycle = DISABLE;
|
||||
InitStruct->OneShot = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует блок "мертвого времени" PWMx согласно параметрам структуры InitStruct
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_DB_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_DB_Init(PWM_TypeDef* PWMx, PWM_DB_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_DB_InConfig(PWMx, InitStruct->In);
|
||||
PWM_DB_OutConfig(PWMx, InitStruct->Out);
|
||||
PWM_DB_PolarityConfig(PWMx, InitStruct->Polarity);
|
||||
PWM_DB_SetRiseDelay(PWMx, InitStruct->RiseDelay);
|
||||
PWM_DB_SetFallDelay(PWMx, InitStruct->FallDelay);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_DB_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_DB_StructInit(PWM_DB_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->In = PWM_DB_In_A;
|
||||
InitStruct->Out = PWM_DB_Out_BypassAB;
|
||||
InitStruct->Polarity = PWM_DB_Polarity_ActiveHigh;
|
||||
InitStruct->RiseDelay = 0;
|
||||
InitStruct->FallDelay = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует обработчик сигналов аварии PWMx согласно параметрам структуры PWM_TZ_Init_TypeDef
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_TZ_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_TZ_Init(PWM_TypeDef* PWMx, PWM_TZ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_TZ_ActionAConfig(PWMx, InitStruct->ActionA);
|
||||
PWM_TZ_ActionBConfig(PWMx, InitStruct->ActionB);
|
||||
PWM_TZ_CycleCmd(PWMx, InitStruct->Cycle);
|
||||
PWM_TZ_OneShotCmd(PWMx, InitStruct->OneShot);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_TZ_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_TZ_StructInit(PWM_TZ_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->ActionA = PWM_TZ_Action_ToZ;
|
||||
InitStruct->ActionB = PWM_TZ_Action_ToZ;
|
||||
InitStruct->Cycle = DISABLE;
|
||||
InitStruct->OneShot = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует блок "триггера событий" PWMx, согласно параметрам структуры InitStruct
|
||||
* @param PWMx Выбор модуля PWM, где x лежит в диапазоне 0-2
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_ET_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_ET_Init(PWM_TypeDef* PWMx, PWM_ET_Init_TypeDef* InitStruct)
|
||||
{
|
||||
PWM_ET_SOCAEventConfig(PWMx, InitStruct->EventSOCA);
|
||||
PWM_ET_SOCAPeriodConfig(PWMx, InitStruct->PeriodSOCA);
|
||||
PWM_ET_SOCACmd(PWMx, InitStruct->SOCA);
|
||||
PWM_ET_SOCBEventConfig(PWMx, InitStruct->EventSOCB);
|
||||
PWM_ET_SOCBPeriodConfig(PWMx, InitStruct->PeriodSOCB);
|
||||
PWM_ET_SOCBCmd(PWMx, InitStruct->SOCB);
|
||||
PWM_ET_DRQAEventConfig(PWMx, InitStruct->EventDRQA);
|
||||
PWM_ET_DRQAPeriodConfig(PWMx, InitStruct->PeriodDRQA);
|
||||
PWM_ET_DRQACmd(PWMx, InitStruct->DRQA);
|
||||
PWM_ET_DRQBEventConfig(PWMx, InitStruct->EventDRQB);
|
||||
PWM_ET_DRQBPeriodConfig(PWMx, InitStruct->PeriodDRQB);
|
||||
PWM_ET_DRQBCmd(PWMx, InitStruct->DRQB);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref PWM_ET_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void PWM_ET_StructInit(PWM_ET_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->EventSOCA = PWM_ET_Event_CTREqZero;
|
||||
InitStruct->PeriodSOCA = 0;
|
||||
InitStruct->SOCA = DISABLE;
|
||||
InitStruct->EventSOCB = PWM_ET_Event_CTREqZero;
|
||||
InitStruct->PeriodSOCB = 0;
|
||||
InitStruct->SOCB = DISABLE;
|
||||
InitStruct->EventDRQA = PWM_ET_Event_CTREqZero;
|
||||
InitStruct->PeriodDRQA = 0;
|
||||
InitStruct->DRQA = DISABLE;
|
||||
InitStruct->EventDRQB = PWM_ET_Event_CTREqZero;
|
||||
InitStruct->PeriodDRQB = 0;
|
||||
InitStruct->DRQB = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
187
MDK-ARM/platform/plib035/src/plib035_qep.c
Normal file
187
MDK-ARM/platform/plib035/src/plib035_qep.c
Normal file
@@ -0,0 +1,187 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_qep.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с QEP
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_qep.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup QEP
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup QEP_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры QEP значениями по умолчанию
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_DeInit(void)
|
||||
{
|
||||
RCU_APBRstCmd(RCU_APBRst_QEP, DISABLE);
|
||||
RCU_APBRstCmd(RCU_APBRst_QEP, ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует счетчик позиции QEP согласно параметрам структуры InitStruct
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_PC_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_PC_Init(QEP_PC_Init_TypeDef* InitStruct)
|
||||
{
|
||||
QEP_PC_ModeConfig(InitStruct->Mode);
|
||||
QEP_PC_CountRateConfig(InitStruct->CountRate);
|
||||
QEP_PC_ResetEventConfig(InitStruct->ResetEvent);
|
||||
QEP_PC_InitEventSConfig(InitStruct->InitEventS);
|
||||
QEP_PC_InitEventIConfig(InitStruct->InitEventI);
|
||||
QEP_PC_LatchEventSConfig(InitStruct->LatchEventS);
|
||||
QEP_PC_LatchEventIConfig(InitStruct->LatchEventI);
|
||||
QEP_PC_SetCount(InitStruct->Count);
|
||||
QEP_PC_SetCountInit(InitStruct->CountInit);
|
||||
QEP_PC_SetCountMax(InitStruct->CountMax);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_PC_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_PC_StructInit(QEP_PC_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Mode = QEP_PC_Mode_Quad;
|
||||
InitStruct->CountRate = QEP_PC_CountRate_Single;
|
||||
InitStruct->ResetEvent = QEP_PC_ResetEvent_Index;
|
||||
InitStruct->InitEventS = QEP_PC_InitEventS_None;
|
||||
InitStruct->InitEventI = QEP_PC_InitEventI_None;
|
||||
InitStruct->LatchEventS = QEP_PC_LatchEventS_Rise;
|
||||
InitStruct->LatchEventI = QEP_PC_LatchEventI_None;
|
||||
InitStruct->Count = 0;
|
||||
InitStruct->CountInit = 0;
|
||||
InitStruct->CountMax = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует компаратор счетчика позиции QEP согласно параметрам структуры InitStruct
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_CMP_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_CMP_Init(QEP_CMP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
QEP_CMP_ShadowLoadCmd(InitStruct->ShadowLoad);
|
||||
QEP_CMP_LoadEventConfig(InitStruct->LoadEvent);
|
||||
QEP_CMP_OutConfig(InitStruct->Out);
|
||||
QEP_CMP_OutCmd(InitStruct->OutEn);
|
||||
QEP_CMP_OutPolarityConfig(InitStruct->OutPolarity);
|
||||
QEP_CMP_SetOutWidth(InitStruct->OutWidth);
|
||||
QEP_CMP_SetComp(InitStruct->Comp);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_CMP_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_CMP_StructInit(QEP_CMP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->ShadowLoad = DISABLE;
|
||||
InitStruct->LoadEvent = QEP_CMP_LoadEvent_PCCountEqZero;
|
||||
InitStruct->Out = QEP_CMP_Out_S;
|
||||
InitStruct->OutEn = DISABLE;
|
||||
InitStruct->OutPolarity = QEP_CMP_OutPolarity_ActiveHigh;
|
||||
InitStruct->OutWidth = 0;
|
||||
InitStruct->Comp = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует модуль захвата времени QEP согласно параметрам структуры InitStruct
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_CAP_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_CAP_Init(QEP_CAP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
QEP_CAP_DivShadowLoadCmd(InitStruct->DivShadowLoad);
|
||||
QEP_CAP_ResetEventConfig(InitStruct->ResetEvent);
|
||||
QEP_CAP_DivConfig(InitStruct->PCLKDiv, InitStruct->QCLKDiv);
|
||||
QEP_CAP_LatchEventConfig(InitStruct->LatchEvent);
|
||||
QEP_CAP_SetCount(InitStruct->Count);
|
||||
QEP_CAP_SetPeriod(InitStruct->Period);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref QEP_CAP_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void QEP_CAP_StructInit(QEP_CAP_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->DivShadowLoad = DISABLE;
|
||||
InitStruct->ResetEvent = QEP_CAP_ResetEvent_QCLKDiv;
|
||||
InitStruct->PCLKDiv = QEP_CAP_PCLKDiv_1;
|
||||
InitStruct->QCLKDiv = QEP_CAP_QCLKDiv_1;
|
||||
InitStruct->LatchEvent = QEP_CAP_LatchEvent_ReadPCCount;
|
||||
InitStruct->Count = 0;
|
||||
InitStruct->Period = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
523
MDK-ARM/platform/plib035/src/plib035_rcu.c
Normal file
523
MDK-ARM/platform/plib035/src/plib035_rcu.c
Normal file
@@ -0,0 +1,523 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_rcu.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с RCU
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_rcu.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup RCU
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup RCU_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup RCU_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup RCU_TIMEOUT_DEFINE Значения для таймаутов
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define RCU_SYSCLK_CHANGE_TIMEOUT 10000 /*!< Время ожидания смены источника тактирования */
|
||||
#define RCU_PLLCLK_LOCK_TIMEOUT 10000 /*!< Время ожидания стабилизации выходной частоты PLL */
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup RCU_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты генерации выбранного источника
|
||||
* @param Clk Выбор тактового сигнала
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
static uint32_t getSysClkFreq(RCU_SysClk_TypeDef Clk)
|
||||
{
|
||||
uint32_t clk_freq = 0;
|
||||
|
||||
switch (Clk) {
|
||||
case RCU_SysClk_OSIClk:
|
||||
clk_freq = RCU_GetOSIClkFreq();
|
||||
break;
|
||||
case RCU_SysClk_OSEClk:
|
||||
clk_freq = RCU_GetOSEClkFreq();
|
||||
break;
|
||||
case RCU_SysClk_PLLClk:
|
||||
clk_freq = RCU_GetPLLClkFreq();
|
||||
break;
|
||||
case RCU_SysClk_PLLDivClk:
|
||||
clk_freq = RCU_GetPLLDivClkFreq();
|
||||
break;
|
||||
}
|
||||
|
||||
return clk_freq;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты генерации выбранного источника
|
||||
* @param Clk Выбор тактового сигнала
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
static uint32_t getPeriphClkFreq(RCU_PeriphClk_TypeDef Clk)
|
||||
{
|
||||
uint32_t clk_freq = 0;
|
||||
|
||||
switch (Clk) {
|
||||
case RCU_PeriphClk_OSEClk:
|
||||
clk_freq = RCU_GetOSEClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_PLLClk:
|
||||
clk_freq = RCU_GetPLLClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_PLLDivClk:
|
||||
clk_freq = RCU_GetPLLDivClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_OSIClk:
|
||||
clk_freq = RCU_GetOSIClkFreq();
|
||||
break;
|
||||
}
|
||||
|
||||
return clk_freq;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты генерации выбранного источника
|
||||
* @param Clk Выбор тактового сигнала
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
static uint32_t getSysPeriphClkFreq(RCU_SysPeriphClk_TypeDef Clk)
|
||||
{
|
||||
uint32_t clk_freq = 0;
|
||||
|
||||
switch (Clk) {
|
||||
case RCU_SysPeriphClk_OSEClk:
|
||||
clk_freq = RCU_GetOSEClkFreq();
|
||||
break;
|
||||
case RCU_SysPeriphClk_PLLClk:
|
||||
clk_freq = RCU_GetPLLClkFreq();
|
||||
break;
|
||||
case RCU_SysPeriphClk_PLLDivClk:
|
||||
clk_freq = RCU_GetPLLDivClkFreq();
|
||||
break;
|
||||
case RCU_SysPeriphClk_OSIClk:
|
||||
clk_freq = RCU_GetOSIClkFreq();
|
||||
break;
|
||||
}
|
||||
|
||||
return clk_freq;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты тактового сигнала OSICLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetOSIClkFreq()
|
||||
{
|
||||
return OSICLK_VAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты тактового сигнала OSECLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetOSEClkFreq()
|
||||
{
|
||||
return OSECLK_VAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты тактового сигнала PLLCLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetPLLClkFreq()
|
||||
{
|
||||
uint32_t pll_n, pll_m, pll_refclk;
|
||||
RCU_PLL_OD_TypeDef pll_od;
|
||||
|
||||
pll_n = READ_REG(RCU->PLLCFG_bit.N);
|
||||
pll_m = READ_REG(RCU->PLLCFG_bit.M);
|
||||
pll_od = (RCU_PLL_OD_TypeDef)READ_REG(RCU->PLLCFG_bit.OD);
|
||||
if (READ_REG(RCU->PLLCFG_bit.REFSRC) == RCU_PLL_Ref_OSIClk)
|
||||
pll_refclk = OSICLK_VAL;
|
||||
else // RCU->PLLCFG_bit.REFSRC == RCU_PLLCFG_REFSRC_OSECLK
|
||||
pll_refclk = OSECLK_VAL;
|
||||
return (pll_refclk * pll_m) / (pll_n * (1 << (uint32_t)pll_od));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты тактового сигнала PLLDIVCLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetPLLDivClkFreq()
|
||||
{
|
||||
uint32_t pll_div;
|
||||
|
||||
pll_div = RCU->PLLDIV_bit.DIV + 1;
|
||||
|
||||
return RCU_GetPLLClkFreq() / pll_div;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты SYSCLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetSysClkFreq()
|
||||
{
|
||||
RCU_SysClk_TypeDef sys_clk;
|
||||
|
||||
sys_clk = RCU_SysClkStatus();
|
||||
|
||||
return getSysClkFreq(sys_clk);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты UARTCLK
|
||||
* @param UARTx_Num Порядковый номер блока UART
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetUARTClkFreq(UART_Num_TypeDef UARTx_Num)
|
||||
{
|
||||
RCU_PeriphClk_TypeDef uart_clk;
|
||||
uint32_t div_val;
|
||||
|
||||
uart_clk = (RCU_PeriphClk_TypeDef)READ_REG(RCU->UARTCFG[UARTx_Num].UARTCFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->UARTCFG[UARTx_Num].UARTCFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->UARTCFG[UARTx_Num].UARTCFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getPeriphClkFreq(uart_clk) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты SPICLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetSPIClkFreq()
|
||||
{
|
||||
RCU_PeriphClk_TypeDef spi_clk;
|
||||
uint32_t div_val;
|
||||
|
||||
spi_clk = (RCU_PeriphClk_TypeDef)READ_REG(RCU->SPICFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->SPICFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->SPICFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getPeriphClkFreq(spi_clk) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты ADCCLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetADCClkFreq()
|
||||
{
|
||||
RCU_PeriphClk_TypeDef adc_clk;
|
||||
uint32_t div_val;
|
||||
|
||||
adc_clk = (RCU_PeriphClk_TypeDef)READ_REG(RCU->ADCCFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->ADCCFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->ADCCFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getPeriphClkFreq(adc_clk) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты WDTCLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetWDTClkFreq()
|
||||
{
|
||||
RCU_SysPeriphClk_TypeDef wdt_clk;
|
||||
uint32_t div_val;
|
||||
|
||||
wdt_clk = (RCU_SysPeriphClk_TypeDef)READ_REG(RCU->WDTCFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->WDTCFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->WDTCFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getSysPeriphClkFreq(wdt_clk) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты TRACECLK
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetTraceClkFreq()
|
||||
{
|
||||
RCU_SysPeriphClk_TypeDef trace_clk;
|
||||
uint32_t div_val;
|
||||
|
||||
trace_clk = (RCU_SysPeriphClk_TypeDef)READ_REG(RCU->TRACECFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->TRACECFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->TRACECFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getSysPeriphClkFreq(trace_clk) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение значения частоты CLKOUT
|
||||
* @retval Val Значение Гц
|
||||
*/
|
||||
uint32_t RCU_GetClkOutFreq()
|
||||
{
|
||||
RCU_SysPeriphClk_TypeDef clkout;
|
||||
uint32_t div_val;
|
||||
|
||||
clkout = (RCU_SysPeriphClk_TypeDef)READ_REG(RCU->CLKOUTCFG_bit.CLKSEL);
|
||||
if (READ_REG(RCU->CLKOUTCFG_bit.DIVEN))
|
||||
div_val = 2 * (READ_REG(RCU->CLKOUTCFG_bit.DIVN) + 1);
|
||||
else
|
||||
div_val = 1;
|
||||
|
||||
return getSysPeriphClkFreq(clkout) / div_val;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Автоматическая конфигурация PLL для получения желаемой системной частоты
|
||||
* @attention Если Freq < 30 МГц, то в качестве системной частоты может быть использован
|
||||
* выход делителя PLLDIV
|
||||
* @param Ref Выбор источника опорного сигнала PLL.
|
||||
* Параметр принимает любое значение из @ref RCC_PLLRef_TypeDef.
|
||||
* @param SysClkFreq Желаемая системная частота в Гц
|
||||
* Параметр принимает любые значения из диапазона 1000000-100000000, кратные 1000000.
|
||||
* Некоторые значения частот получить невозможно.
|
||||
* @retval Status
|
||||
*/
|
||||
OperationStatus RCU_PLL_AutoConfig(uint32_t SysClkFreq, RCU_PLL_Ref_TypeDef Ref)
|
||||
{
|
||||
RCU_PLL_Init_TypeDef PLL_Init_Struct;
|
||||
uint32_t ref_freq;
|
||||
RCU_SysClk_TypeDef sysclk_sel;
|
||||
OperationStatus status = OK;
|
||||
|
||||
RCU_PLL_StructInit(&PLL_Init_Struct);
|
||||
|
||||
if (!IS_RCU_SYSCLK_FREQ(SysClkFreq))
|
||||
return ERROR;
|
||||
|
||||
PLL_Init_Struct.Ref = Ref;
|
||||
if ((PLL_Init_Struct.Ref == RCU_PLL_Ref_OSEClk) &&
|
||||
IS_RCU_PLL_REF_FREQ(OSECLK_VAL))
|
||||
ref_freq = OSECLK_VAL;
|
||||
else if (PLL_Init_Struct.Ref == RCU_PLL_Ref_OSIClk)
|
||||
ref_freq = OSICLK_VAL;
|
||||
else
|
||||
return ERROR;
|
||||
|
||||
if (SysClkFreq < 30000000) {
|
||||
PLL_Init_Struct.DivVal = 40000000 / SysClkFreq;
|
||||
PLL_Init_Struct.DivEn = ENABLE;
|
||||
SysClkFreq = SysClkFreq * (PLL_Init_Struct.DivVal + 1);
|
||||
sysclk_sel = RCU_SysClk_PLLDivClk;
|
||||
} else
|
||||
sysclk_sel = RCU_SysClk_PLLClk;
|
||||
|
||||
if (SysClkFreq >= 60000000)
|
||||
PLL_Init_Struct.OD = RCU_PLL_OD_Div2;
|
||||
else if (SysClkFreq >= 30000000)
|
||||
PLL_Init_Struct.OD = RCU_PLL_OD_Div4;
|
||||
else
|
||||
return ERROR;
|
||||
|
||||
uint32_t div_solved = 0;
|
||||
for (uint32_t i = 1; i < 64; i++) {
|
||||
uint32_t tmp_n = i;
|
||||
uint32_t tmp_m = (SysClkFreq * (1 << PLL_Init_Struct.OD)) / (ref_freq / i);
|
||||
if ((ref_freq % tmp_n == 0) &&
|
||||
IS_RCU_PLL_CMP_FREQ(ref_freq / tmp_n) &&
|
||||
((SysClkFreq * (1 << PLL_Init_Struct.OD)) % (ref_freq / tmp_n) == 0) &&
|
||||
IS_RCU_PLL_M(tmp_m) &&
|
||||
IS_RCU_PLL_VCO_FREQ(ref_freq * tmp_m / tmp_n)) {
|
||||
div_solved = 1;
|
||||
PLL_Init_Struct.N = tmp_n;
|
||||
PLL_Init_Struct.M = tmp_m;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!div_solved)
|
||||
status = ERROR;
|
||||
else
|
||||
status = RCU_PLL_Init(&PLL_Init_Struct);
|
||||
if (status != OK)
|
||||
return status;
|
||||
|
||||
if (SysClkFreq >= 90000000)
|
||||
MFLASH_LatencyConfig(3);
|
||||
else if (SysClkFreq >= 60000000)
|
||||
MFLASH_LatencyConfig(2);
|
||||
else if (SysClkFreq >= 30000000)
|
||||
MFLASH_LatencyConfig(1);
|
||||
else
|
||||
MFLASH_LatencyConfig(0);
|
||||
|
||||
status = RCU_SysClkChangeCmd(sysclk_sel);
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует PLL согласно параметрам структуры InitStruct.
|
||||
* Значение выходной частоты PLL вычисляется по формуле:<br><br>
|
||||
* <center>FOUT = (FIN × M) / (N × (2^OD)),</center>
|
||||
* где FIN – входная частота PLL.<br>
|
||||
* @attention При расчете коэффициентов деления PLL должны выполняться следующие условия:
|
||||
* - 4 МГц <= FIN <= 64 МГц (REF),
|
||||
* - 4 MГц <= FIN/N <= 20 МГц (CMP),
|
||||
* - 120 МГц <= FIN*M/N <= 200 МГц (VCO),
|
||||
* - 15 МГц <= FOUT <= 100 МГц;
|
||||
*
|
||||
* @param InitStruct Указатель на структуру типа @ref RCU_PLL_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval Status
|
||||
*/
|
||||
OperationStatus RCU_PLL_Init(RCU_PLL_Init_TypeDef* InitStruct)
|
||||
{
|
||||
uint32_t timeout = RCU_PLLCLK_LOCK_TIMEOUT;
|
||||
OperationStatus status = OK;
|
||||
|
||||
assert_param(IS_FUNCTIONAL_STATE(InitStruct->DivEn));
|
||||
assert_param(IS_RCU_PLL_DIV(InitStruct->DivVal));
|
||||
assert_param(IS_RCU_PLL_M(InitStruct->M));
|
||||
assert_param(IS_RCU_PLL_N(InitStruct->N));
|
||||
assert_param(IS_RCU_PLL_OD(InitStruct->OD));
|
||||
assert_param(IS_RCU_PLL_REF(InitStruct->Ref));
|
||||
|
||||
MODIFY_REG(RCU->PLLCFG, (RCU_PLLCFG_N_Msk | RCU_PLLCFG_M_Msk | RCU_PLLCFG_N_Msk | RCU_PLLCFG_OD_Msk | RCU_PLLCFG_REFSRC_Msk),
|
||||
(InitStruct->N << RCU_PLLCFG_N_Pos |
|
||||
InitStruct->M << RCU_PLLCFG_M_Pos |
|
||||
InitStruct->OD << RCU_PLLCFG_OD_Pos |
|
||||
InitStruct->Ref << RCU_PLLCFG_REFSRC_Pos));
|
||||
MODIFY_REG(RCU->PLLDIV, RCU_PLLDIV_DIV_Msk | RCU_PLLDIV_DIVEN_Msk,
|
||||
InitStruct->DivVal << RCU_PLLDIV_DIV_Pos |
|
||||
InitStruct->DivEn << RCU_PLLDIV_DIVEN_Pos);
|
||||
RCU_PLL_OutCmd(ENABLE);
|
||||
while (timeout) {
|
||||
if (RCU_PLL_LockStatus()) {
|
||||
break;
|
||||
} else {
|
||||
timeout--;
|
||||
}
|
||||
}
|
||||
if (!timeout) {
|
||||
status = ERROR;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию
|
||||
* @param InitStruct Указатель на структуру типа @ref RCU_PLL_Init_TypeDef,
|
||||
* которую необходимо проинициализировать
|
||||
* @retval void
|
||||
*/
|
||||
void RCU_PLL_StructInit(RCU_PLL_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->Ref = RCU_PLL_Ref_OSEClk;
|
||||
InitStruct->DivVal = 0;
|
||||
InitStruct->DivEn = DISABLE;
|
||||
InitStruct->M = 0;
|
||||
InitStruct->N = 0;
|
||||
InitStruct->OD = RCU_PLL_OD_Disable;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры PLL значениями по умолчанию
|
||||
* @retval void
|
||||
*/
|
||||
void RCU_PLL_DeInit()
|
||||
{
|
||||
RCU_PLL_OutCmd(DISABLE);
|
||||
CLEAR_REG(RCU->PLLCFG);
|
||||
CLEAR_REG(RCU->PLLDIV);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Переключение источника для системного тактового сигнала
|
||||
* @param SysClk Выбор источника
|
||||
* @retval void
|
||||
*/
|
||||
OperationStatus RCU_SysClkChangeCmd(RCU_SysClk_TypeDef SysClk)
|
||||
{
|
||||
uint32_t timeout = RCU_SYSCLK_CHANGE_TIMEOUT;
|
||||
OperationStatus status = OK;
|
||||
|
||||
assert_param(IS_RCU_SYS_CLK(SysClk));
|
||||
|
||||
RCU_SysClkConfig(SysClk);
|
||||
|
||||
while (timeout) {
|
||||
if (RCU_BusyStatus()) {
|
||||
timeout--;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!timeout || (RCU_SysClkStatus() != SysClk)) {
|
||||
status = ERROR;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
110
MDK-ARM/platform/plib035/src/plib035_spi.c
Normal file
110
MDK-ARM/platform/plib035/src/plib035_spi.c
Normal file
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_spi.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с SPI
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_spi.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup SPI
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup SPI_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры SPI значениями по умолчанию
|
||||
* @retval void
|
||||
*/
|
||||
void SPI_DeInit()
|
||||
{
|
||||
RCU_SPIRstCmd(DISABLE);
|
||||
RCU_SPIRstCmd(ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует SPI согласно параметрам структуры InitStruct.
|
||||
* @param InitStruct Указатель на структуру типа @ref SPI_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию.
|
||||
* @retval Status Статус результата инициализации
|
||||
*/
|
||||
void SPI_Init(SPI_Init_TypeDef* InitStruct)
|
||||
{
|
||||
|
||||
SPI_SCKDivConfig(InitStruct->SCKDiv, InitStruct->SCKDivExtra);
|
||||
SPI_DataWidthConfig(InitStruct->DataWidth);
|
||||
SPI_FrameFormatConfig(InitStruct->FrameFormat);
|
||||
SPI_ModeConfig(InitStruct->Mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию.
|
||||
* @param InitStruct Указатель на структуру типа @ref SPI_Init_TypeDef,
|
||||
* которую необходимо проинициализировать.
|
||||
* @retval void
|
||||
*/
|
||||
void SPI_StructInit(SPI_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->SCKDiv = 0;
|
||||
InitStruct->SCKDivExtra = 2;
|
||||
InitStruct->DataWidth = SPI_DataWidth_8;
|
||||
InitStruct->FrameFormat = SPI_FrameFormat_SPI;
|
||||
InitStruct->Mode = SPI_Mode_Master;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
100
MDK-ARM/platform/plib035/src/plib035_tmr.c
Normal file
100
MDK-ARM/platform/plib035/src/plib035_tmr.c
Normal file
@@ -0,0 +1,100 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_tmr.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с TMR
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_tmr.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup TMR
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup TMR_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Настройка периода опустошения выбранного таймера.
|
||||
* @attention В качестве альтернативы может применяться как ручное заполнение
|
||||
* регистра перезагрузки @ref TMR_SetLoad так и автоматический расчет,
|
||||
* исходя из желаемой частоты опустошения таймера @ref TMR_FreqConfig.
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param TimerClkFreq Частота в Гц, которой тактируется таймер
|
||||
* @param TimerPeriod Период опустошения таймера в мкс
|
||||
* @retval void
|
||||
*/
|
||||
void TMR_PeriodConfig(TMR_TypeDef* TMRx, uint32_t TimerClkFreq, uint32_t TimerPeriod)
|
||||
{
|
||||
TMR_SetLoad(TMRx, TimerPeriod * (TimerClkFreq / 1000000));
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Настройка частоты опустошения выбранного таймера.
|
||||
* @attention В качестве альтернативы может применяться как ручное заполнение
|
||||
* регистра перезагрузки @ref TMR_SetLoad так и автоматический расчет,
|
||||
* исходя из желаемого периода опустошения таймера @ref TMR_PeriodConfig.
|
||||
* @param TMRx Выбор таймера, где x лежит в диапазоне 0-3
|
||||
* @param TimerClkFreq Частота в Гц, которой тактируется таймер
|
||||
* @param TimerFreq Частота опустошения таймера в Гц
|
||||
* @retval void
|
||||
*/
|
||||
void TMR_FreqConfig(TMR_TypeDef* TMRx, uint32_t TimerClkFreq, uint32_t TimerFreq)
|
||||
{
|
||||
TMR_SetLoad(TMRx, TimerClkFreq / TimerFreq);
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
151
MDK-ARM/platform/plib035/src/plib035_uart.c
Normal file
151
MDK-ARM/platform/plib035/src/plib035_uart.c
Normal file
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_uart.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с UART
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_uart.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup UART
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup UART_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Автоматический расчёт и установка делителей для нужной скорости передачи
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param State Выбор состояния
|
||||
* @retval void
|
||||
*/
|
||||
void UART_AutoBaudConfig(UART_TypeDef* UARTx, uint32_t BaudRate)
|
||||
{
|
||||
UART_Num_TypeDef UARTx_Num;
|
||||
uint32_t uart_clk_freq, int_div, frac_div;
|
||||
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
|
||||
if (UARTx == UART0) {
|
||||
UARTx_Num = UART0_Num;
|
||||
} else {
|
||||
UARTx_Num = UART1_Num;
|
||||
}
|
||||
|
||||
uart_clk_freq = RCU_GetUARTClkFreq(UARTx_Num);
|
||||
int_div = uart_clk_freq / (16 * BaudRate);
|
||||
frac_div = (uint32_t)((uart_clk_freq / (16.0f * BaudRate) - int_div) * 64.0f + 0.5f);
|
||||
UART_BaudDivConfig(UARTx, int_div, frac_div);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Устанавливает все регистры UART значениями по умолчанию
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @retval void
|
||||
*/
|
||||
void UART_DeInit(UART_TypeDef* UARTx)
|
||||
{
|
||||
UART_Num_TypeDef UARTx_Num;
|
||||
|
||||
assert_param(IS_UART_PERIPH(UARTx));
|
||||
|
||||
if (UARTx == UART0) {
|
||||
UARTx_Num = UART0_Num;
|
||||
} else {
|
||||
UARTx_Num = UART1_Num;
|
||||
}
|
||||
|
||||
RCU_UARTRstCmd(UARTx_Num, DISABLE);
|
||||
RCU_UARTRstCmd(UARTx_Num, ENABLE);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализирует UARTx согласно параметрам структуры InitStruct.
|
||||
* @param UARTx Выбор модуля UART, где x=0|1
|
||||
* @param InitStruct Указатель на структуру типа @ref UART_Init_TypeDef,
|
||||
* которая содержит конфигурационную информацию.
|
||||
* @retval Status Статус результата инициализации
|
||||
*/
|
||||
void UART_Init(UART_TypeDef* UARTx, UART_Init_TypeDef* InitStruct)
|
||||
{
|
||||
UART_AutoBaudConfig(UARTx, InitStruct->BaudRate);
|
||||
UART_DataWidthConfig(UARTx, InitStruct->DataWidth);
|
||||
UART_StopBitConfig(UARTx, InitStruct->StopBit);
|
||||
UART_ParityBitConfig(UARTx, InitStruct->ParityBit);
|
||||
UART_FIFOCmd(UARTx, InitStruct->FIFO);
|
||||
UART_TxCmd(UARTx, InitStruct->Tx);
|
||||
UART_RxCmd(UARTx, InitStruct->Rx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Заполнение каждого члена структуры InitStruct значениями по умолчанию.
|
||||
* @param InitStruct Указатель на структуру типа @ref UART_Init_TypeDef,
|
||||
* которую необходимо проинициализировать.
|
||||
* @retval void
|
||||
*/
|
||||
void UART_StructInit(UART_Init_TypeDef* InitStruct)
|
||||
{
|
||||
InitStruct->BaudRate = 9600;
|
||||
InitStruct->DataWidth = UART_DataWidth_8;
|
||||
InitStruct->FIFO = DISABLE;
|
||||
InitStruct->ParityBit = UART_ParityBit_Disable;
|
||||
InitStruct->StopBit = UART_StopBit_1;
|
||||
InitStruct->Rx = DISABLE;
|
||||
InitStruct->Tx = DISABLE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
70
MDK-ARM/platform/plib035/src/plib035_wdt.c
Normal file
70
MDK-ARM/platform/plib035/src/plib035_wdt.c
Normal file
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file plib035_wdt.c
|
||||
*
|
||||
* @brief Файл содержит реализацию функций для работы с WDT
|
||||
*
|
||||
* @author НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* <h2><center>© 2018 ОАО "НИИЭТ"</center></h2>
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "plib035_wdt.h"
|
||||
|
||||
/** @addtogroup Peripheral
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @addtogroup WDT
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Private Приватные данные
|
||||
* @{
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Private_Defines Приватные константы
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** @defgroup WDT_Private_Functions Приватные функции
|
||||
* @{
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/**
|
||||
* @}
|
||||
*/
|
||||
|
||||
/******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE****/
|
||||
Reference in New Issue
Block a user