Проект перенесен в папку MDK-ARM
This commit is contained in:
588
MDK-ARM/Core/App/adc.c
Normal file
588
MDK-ARM/Core/App/adc.c
Normal file
@@ -0,0 +1,588 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file adc.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер ADC на основе PLIB035.
|
||||
* Этот файл содержит:
|
||||
* + Инициализацию ADC и аналогового модуля (AM)
|
||||
* + Управление секвенсорами (SEQ0, SEQ1):
|
||||
* - Инициализацию и конфигурацию секвенсоров
|
||||
* - Запуск и остановку преобразований с буфером
|
||||
* - Обработку прерываний секвенсоров
|
||||
* - Установку callback-функций для событий:
|
||||
* - завершение секвенсора
|
||||
* - половина буфера
|
||||
* - полный буфера
|
||||
* - ошибка
|
||||
* + Управление цифровыми компараторами (DC0-DC3):
|
||||
* - Инициализацию и конфигурацию компараторов
|
||||
* - Запуск и остановку компараторов
|
||||
* - Обработку прерываний компараторов
|
||||
* - Установку callback-функций для событий:
|
||||
* - срабатывание компаратора
|
||||
* - ошибка
|
||||
* + Функции для работы с каналами ADC
|
||||
* + Программный запуск преобразований
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Использование этого драйвера предполагает наличие корректных настроек:
|
||||
* - Определены конфигурационные структуры adc_seqx_config и adc_dcx_config
|
||||
* в periph_config.h
|
||||
* - Настроено тактирование ADC через RCU
|
||||
* - Для использования прерываний - включены соответствующие NVIC IRQ
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот драйвер #####
|
||||
==============================================================================
|
||||
|
||||
-------------------------- Общие функции АЦП --------------------------------
|
||||
|
||||
1. Инициализация АЦП:
|
||||
(+) adc_init_first() - обязательный вызов перед использованием АЦП
|
||||
(+) Настраивает тактирование, GPIO и ожидает готовности аналогового модуля
|
||||
|
||||
2. Калибровка каналов:
|
||||
(+) ADC_Channel_Calibr(&hadc, channel, OFFSET, GAIN) - калибровка смещения и усиления
|
||||
(+) Формула калибровки: Dc = Dr * (4096+GAIN)/4096 + OFFSET
|
||||
|
||||
3. Чтение значений каналов:
|
||||
(+) ADC_Channel_GetValue(&hadc, channel) - получение текущего значения канала
|
||||
(+) Данные обновляются автоматически при работе секвенсоров
|
||||
|
||||
4. Инициализация GPIO:
|
||||
(+) adc_gpio_init(hadc.ChannelEnable) - настраивает пины выбранных каналов
|
||||
(+) Вызывается автоматически в adc_init_first()
|
||||
|
||||
------------------------ Секвенсоры (SEQ0, SEQ1) ----------------------------
|
||||
|
||||
1. Настройка в periph_config.h:
|
||||
(+) Определите adc_seq0_config, adc_seq1_config
|
||||
(+) Настройте ADC_ClockSource и ADC_ClockMHz для тактирования АЦП
|
||||
(+) Определите adc_ch_config для включения нужных каналов
|
||||
|
||||
2. Инициализация секвенсоров:
|
||||
(+) adc_seq_init(&hadc, ADC_SEQ_Num_0, &adc_seq0_config) - инициализация SEQ0
|
||||
(+) Аналогично для SEQ1 при необходимости
|
||||
|
||||
3. Работа с секвенсорами:
|
||||
(+) ADC_SEQ_Start(&hadc, ADC_SEQ_Num_0, buffer, buffer_size) - запуск с буфером
|
||||
(+) ADC_SEQ_Stop(&hadc, ADC_SEQ_Num_0) - остановка секвенсора
|
||||
(+) ADC_SEQ_Set_Callback(&hadc, ADC_SEQ_Num_0, тип, func) - установка обработчика
|
||||
(+) ADC_SEQ_SoftwareStart() - программный запуск преобразования
|
||||
|
||||
4. Обработка прерываний секвенсоров:
|
||||
(+) ADC_SEQ0_IRQHandler - вызвать adc_seq_irq_handler(&hadc, ADC_SEQ_Num_0)
|
||||
(+) ADC_SEQ1_IRQHandler - вызвать adc_seq_irq_handler(&hadc, ADC_SEQ_Num_1)
|
||||
|
||||
------------------------ Цифровые компараторы (DC) --------------------------
|
||||
|
||||
|
||||
==============================================================================
|
||||
##### Особенности работы #####
|
||||
==============================================================================
|
||||
|
||||
-------------------------- Общие особенности --------------------------------
|
||||
|
||||
- Частота ADC:
|
||||
- Задается через ADC_ClockMHz в periph_config.h
|
||||
- Автоматически настраивается делитель от источника тактирования
|
||||
|
||||
- Аналоговый модуль (AM):
|
||||
- Требует времени для старта после включения (до 1 мс)
|
||||
- adc_init_first() ожидает готовности AM с таймаутом 1 секунда
|
||||
- При неудаче вызывает Error_Handler()
|
||||
|
||||
- Калибровка:
|
||||
- OFFSET: смещение в диапазоне [-255, 255] квантов АЦП
|
||||
- GAIN: коэффициент усиления в диапазоне [-255, 255] квантов АЦП (4096+GAIN)
|
||||
- Калибровка применяется аппаратно для каждого канала отдельно
|
||||
|
||||
------------------------ Секвенсоры (SEQ0, SEQ1) ----------------------------
|
||||
|
||||
- Буферизация данных:
|
||||
- Данные в буфере хранятся в формате [канал][время]
|
||||
- При buffer_size=100 для 2 каналов буфер будет 200 элементов
|
||||
- Буфер может быть кольцевым (BufferCircular=ENABLE)
|
||||
|
||||
- Прерывания секвенсоров:
|
||||
- Генерируются после заданного количества рестартов (ITCount)
|
||||
- ITCount=0 означает прерывание после каждого прохода секвенсора
|
||||
- Данные автоматически читаются из FIFO в прерывании
|
||||
|
||||
- Работа с усреднением:
|
||||
- Аппаратное усреднение измерения:
|
||||
- 2, 4, 8, 16, 32 или 64 выборок (SEQ_Init.ReqAverage)
|
||||
- Включается через SEQ_Init.ReqAverageEn
|
||||
- Усредненные значения помещаются в FIFO как единый результат
|
||||
- Аппаратное усреднение рестартов
|
||||
- 2, 4, 8, 16, 32, 64, 128, 256 выборок (SER_Init.RestartCount + 1)
|
||||
- Включается через SEQ_Init.RestartAverageEn
|
||||
- Усредненные значения помещаются в FIFO как единый результат
|
||||
|
||||
- Таймер рестартов:
|
||||
- Период в тиках ADC_ClockMHz/2 (драйвер автоматически делит на 2)
|
||||
- Используется для периодического запуска секвенсора
|
||||
- При RestartTimer=0 рестарт происходит немедленно
|
||||
|
||||
- Чтение FIFO:
|
||||
- FIFO буфер на 32 элемента автоматически читается в прерывании
|
||||
- Данные распределяются по каналам согласно последовательности в Req[0..3]
|
||||
- При переполнении FIFO (>32 элементов до прерывания) возможна потеря данных
|
||||
|
||||
------------------------ Цифровые компараторы (DC) --------------------------
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "periph_config.h"
|
||||
|
||||
ADC_HandleTypeDef hadc; /*!< Хендл ADC */
|
||||
|
||||
//-- Private function prototypes -----------------------------------------------
|
||||
static void __adc_seq_fifo_read(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num);
|
||||
static int __adc_seq_calc_fifo_load(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num);
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
//-- ADC Init functions --------------------------------------------------------
|
||||
/**
|
||||
* @brief Первичная инициализация ADC
|
||||
* @details Настройка ADC и хендла: тактирования, прерывания
|
||||
* и секвенсоры с компараторами
|
||||
*/
|
||||
void adc_init_first(void)
|
||||
{
|
||||
#if (USE_ADC_SEQ0==1) || (USE_ADC_SEQ1==1) || (USE_ADC_DC0==1) || (USE_ADC_DC1==1) || (USE_ADC_DC2==1) || (USE_ADC_DC3==1)
|
||||
// Настройка тактирования
|
||||
if(rcu_set_clock_adc(ADC_ClockSource, ADC_ClockMHz, ENABLE) != OK)
|
||||
{
|
||||
Error_Handler();
|
||||
}
|
||||
RCU_ADCRstCmd(ENABLE);
|
||||
// Включаем аналоговый модуль
|
||||
ADC_AM_Cmd(ENABLE);
|
||||
|
||||
// Настройка пинов для ADC
|
||||
hadc.ChannelEnable = &adc_ch_config;
|
||||
adc_gpio_init(hadc.ChannelEnable);
|
||||
|
||||
hadc.Instance = ADC;
|
||||
#endif
|
||||
|
||||
#if (USE_ADC_SEQ0==1)
|
||||
adc_seq_init(&hadc, ADC_SEQ_Num_0, &adc_seq0_config);
|
||||
if(hadc.SEQ[ADC_SEQ_Num_0].Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(ADC_SEQ0_IRQn);
|
||||
}
|
||||
#endif
|
||||
#if (USE_ADC_SEQ1==1)
|
||||
adc_seq_init(&hadc, ADC_SEQ_Num_1, &adc_seq1_config);
|
||||
if(hadc.SEQ[ADC_SEQ_Num_1].Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(ADC_SEQ1_IRQn);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (USE_ADC_SEQ0==1) || (USE_ADC_SEQ1==1) || (USE_ADC_DC0==1) || (USE_ADC_DC1==1) || (USE_ADC_DC2==1) || (USE_ADC_DC3==1)
|
||||
uint32_t starttick = millis();
|
||||
while (!ADC_AM_ReadyStatus()) {
|
||||
if((millis() - starttick) > 1000)
|
||||
Error_Handler();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Записать калибровочные значения канала
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param channel номер канала
|
||||
* @param OFFSET Коэффициент корректировки смещения нуля АЦП в квантах [-255:255]
|
||||
* @param GAIN Коэффициент корректировки усиления зн АЦП в квантах [-255:255]
|
||||
* @retval значение ADC (0 если данные невалидны)
|
||||
* @details Результат преобразования передается на схему коррекции, которая нивелирует
|
||||
* ошибку усиления и смещения нуля и работа которой описывается формулой
|
||||
* Dc = Dr * (4096+GAIN)/4096 + OFFSET
|
||||
*/
|
||||
OperationStatus ADC_Channel_Calibr(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel, int OFFSET, int GAIN)
|
||||
{
|
||||
if (!hadc || (int)channel >= ADC_CH_Total)
|
||||
return ERROR;
|
||||
|
||||
ADC_CH_SetOffsetTrim(channel, OFFSET);
|
||||
ADC_CH_SetGainTrim(channel, GAIN);
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего значения канала
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param channel номер канала
|
||||
* @retval значение ADC (0 если данные невалидны)
|
||||
*/
|
||||
uint16_t ADC_Channel_GetValue(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel)
|
||||
{
|
||||
if (!hadc || (int)channel >= ADC_CH_Total)
|
||||
return 0;
|
||||
|
||||
return hadc->ChannelData[channel];
|
||||
}
|
||||
|
||||
//-- ADC Sequencers API functions ----------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Инициализация секвенсора АЦП
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @param NewConfig указатель на новую конфигурацию ADC, иначе используется та, что в структуре
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus adc_seq_init(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_ExtInit_TypeDef *NewConfig)
|
||||
{
|
||||
if(!hadc || !hadc->Instance)
|
||||
return ERROR;
|
||||
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
|
||||
if(NewConfig != NULL)
|
||||
{
|
||||
hseq->Config = NewConfig;
|
||||
}
|
||||
if(hseq->Config == NULL)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
ADC_SEQ_ExtInit_TypeDef *conf = hseq->Config;
|
||||
if(conf->SEQ_Init.RestartTimer) // не значю почему но этот таймер работает в 2 раза медленее чем AdcClk
|
||||
{
|
||||
conf->SEQ_Init.RestartTimer = (conf->SEQ_Init.RestartTimer+1)/2-1; // поэтому дополнительно делим всё на два чтобы работало
|
||||
}
|
||||
|
||||
if(__adc_seq_calc_fifo_load(hadc, SEQ_Num) < 0)
|
||||
return ERROR;
|
||||
|
||||
|
||||
ADC_SEQ_Init(SEQ_Num, &hseq->Config->SEQ_Init);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Установка коллбека секвенсора АЦП
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param CallbackType Тип коллбека
|
||||
* @param Callback Функция коллбека
|
||||
* @retval void
|
||||
*/
|
||||
OperationStatus ADC_SEQ_Set_Callback(ADC_HandleTypeDef* hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_CallbackTypeDef CallbackType, void (*Callback)(void))
|
||||
{
|
||||
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
|
||||
return ERROR;
|
||||
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
|
||||
switch(CallbackType)
|
||||
{
|
||||
case ADC_Callback_SeqCplt:
|
||||
hseq->Config->SEQCpltCallback = Callback;
|
||||
break;
|
||||
case ADC_Callback_Error:
|
||||
hseq->Config->ErrorCallback = Callback;
|
||||
break;
|
||||
case ADC_Callback_BuffFull:
|
||||
hseq->Config->BuffFullCallback = Callback;
|
||||
break;
|
||||
case ADC_Callback_BuffHalf:
|
||||
hseq->Config->BuffFullCallback = Callback;
|
||||
break;
|
||||
default:
|
||||
return ERROR;
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Запуск секвенсора АЦП с буфером
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @param data_buffer указатель на буфер данных [ch][buffer_size] или NULL
|
||||
* @param buffer_size размер буфера для каждого канала (0 если буфер не используется)
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus ADC_SEQ_Start(ADC_HandleTypeDef *hadc,
|
||||
ADC_SEQ_Num_TypeDef SEQ_Num,
|
||||
uint16_t (*data_buffer)[],
|
||||
uint32_t buffer_size)
|
||||
{
|
||||
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
|
||||
return ERROR;
|
||||
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
ADC_SEQ_ExtInit_TypeDef *conf = hseq->Config;
|
||||
|
||||
// Сохраняем буферные параметры
|
||||
hseq->data_buffer = (uint16_t *)data_buffer;
|
||||
hseq->buffer_size = buffer_size;
|
||||
hseq->buffer_count = 0; // Сбрасываем счетчик
|
||||
|
||||
|
||||
// DMA > IT
|
||||
if(conf->SEQ_Init.DMAEn == ENABLE)
|
||||
{
|
||||
conf->IT = DISABLE;
|
||||
}
|
||||
|
||||
// Настраиваем прерывания если нужно
|
||||
if (conf->IT == ENABLE)
|
||||
{
|
||||
uint32_t it_real_cnt = (uint32_t)(conf->ITCount+1)*(conf->SEQ_Init.ReqMax+1);
|
||||
ADC_SEQ_ITConfig(SEQ_Num, it_real_cnt-1, DISABLE);
|
||||
ADC_SEQ_ITCmd(SEQ_Num, ENABLE);
|
||||
}
|
||||
|
||||
// Включаем секвенсор
|
||||
ADC_SEQ_Cmd(SEQ_Num, ENABLE);
|
||||
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Остановка секвенсора АЦП
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus ADC_SEQ_Stop(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
|
||||
return ERROR;
|
||||
|
||||
// ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
|
||||
// Выключаем секвенсор
|
||||
ADC_SEQ_Cmd(SEQ_Num, DISABLE);
|
||||
|
||||
// Выключаем прерывания
|
||||
ADC_SEQ_ITCmd(SEQ_Num, DISABLE);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Программный запуск преобразования
|
||||
*/
|
||||
void ADC_SEQ_SoftwareStart(void)
|
||||
{
|
||||
ADC_SEQ_SwStartCmd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Обработчик прерываний секвенсора
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @retval void
|
||||
*/
|
||||
void adc_seq_irq_handler(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
|
||||
return;
|
||||
// GPIO_SetBits(GPIOA, GPIO_Pin_7);
|
||||
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
ADC_SEQ_ExtInit_TypeDef *conf = hseq->Config;
|
||||
|
||||
// Проверяем флаг прерывания
|
||||
if (ADC_SEQ_ITMaskedStatus(SEQ_Num) == SET)
|
||||
{
|
||||
// Очищаем флаг
|
||||
ADC_SEQ_ITStatusClear(SEQ_Num);
|
||||
|
||||
__adc_seq_fifo_read(hadc, SEQ_Num);
|
||||
}
|
||||
|
||||
// Обработка ошибок
|
||||
if (ADC_SEQ_DMAErrorStatus(SEQ_Num) == SET)
|
||||
{
|
||||
ADC_SEQ_DMAErrorStatusClear(SEQ_Num);
|
||||
|
||||
if (conf->ErrorCallback)
|
||||
{
|
||||
conf->ErrorCallback();
|
||||
}
|
||||
}
|
||||
|
||||
// GPIO_ClearBits(GPIOA, GPIO_Pin_7);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Внутренняя функция для расчета загрузки FIFO буфера
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @retval Кол-во данных FIFO буфера, или -1 если переполнение FIFO
|
||||
* @details Рассчитывает сколько данных накопится в fifo буфере за одно прерывание
|
||||
*/
|
||||
static int __adc_seq_calc_fifo_load(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
ADC_SEQ_ExtInit_TypeDef *conf = hseq->Config;
|
||||
|
||||
int numb_of_data = 0;
|
||||
uint32_t numb_of_req = ((uint32_t)conf->SEQ_Init.ReqMax+1);
|
||||
uint32_t it_cnt = ((uint32_t)conf->ITCount+1);
|
||||
|
||||
|
||||
if(conf->SEQ_Init.RestartAverageEn)
|
||||
{
|
||||
numb_of_data = numb_of_req;
|
||||
}
|
||||
else
|
||||
{
|
||||
numb_of_data = it_cnt*numb_of_req;
|
||||
if(numb_of_data > 32) // Максимальный размер FIFO - 32 элемента, поэтому если слишком многшо данных за время работы перед прерыванием - то ошибка
|
||||
return -1;
|
||||
}
|
||||
|
||||
return numb_of_data;
|
||||
}
|
||||
/**
|
||||
* @brief Внутренняя функция для чтения данных из FIFO
|
||||
* @param hadc указатель на хендл АЦП
|
||||
* @param SEQ_Num номер секвенсора
|
||||
* @retval void
|
||||
* @details Автоматически достает данные из FIFO и складывает их в заданный буфер
|
||||
и в структуру hadc
|
||||
*/
|
||||
static void __adc_seq_fifo_read(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num)
|
||||
{
|
||||
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
|
||||
_ADC_SEQ_TypeDef *SEQx = &hadc->Instance->SEQ[SEQ_Num];
|
||||
ADC_SEQ_ExtInit_TypeDef *conf = hseq->Config;
|
||||
|
||||
// Последний запрос в секвенсоре
|
||||
uint32_t last_request = SEQx->SRQCTL_bit.RQMAX;
|
||||
uint32_t numb_of_request = last_request+1;
|
||||
|
||||
// Читаем все доступные данные из FIFO
|
||||
uint32_t fifo_size = ADC_SEQ_GetFIFOLoad(SEQ_Num);
|
||||
uint32_t req_num = ((int)ADC_SEQ_GetReqCurrent(SEQ_Num)-fifo_size)%(numb_of_request); // первая дата в fifo будет (следующий запрос - количество данных в буфере)
|
||||
while (ADC_SEQ_GetFIFOLoad(SEQ_Num))
|
||||
{
|
||||
uint32_t data = ADC_SEQ_GetFIFOData(SEQ_Num);
|
||||
|
||||
if(ADC_SEQ_GetFIFOLoad(SEQ_Num) == 0)
|
||||
{
|
||||
__NOP();
|
||||
}
|
||||
if ((int)req_num < ADC_SEQ_Req_Total)
|
||||
{
|
||||
ADC_CH_Num_TypeDef channel = conf->SEQ_Init.Req[req_num];
|
||||
|
||||
if ((int)channel < ADC_CH_Total)
|
||||
{
|
||||
// 1. Обновляем текущее значение
|
||||
hadc->ChannelData[channel] = (uint16_t)data;
|
||||
|
||||
// 2. Записываем в буфер если он есть
|
||||
if (hseq->data_buffer &&
|
||||
hseq->buffer_size > 0)
|
||||
{
|
||||
// Вычисляем offset для [ch][buffer_size]
|
||||
uint32_t offset = req_num * hseq->buffer_size +
|
||||
hseq->buffer_count;
|
||||
hseq->data_buffer[offset] = (uint16_t)data;
|
||||
}
|
||||
}
|
||||
|
||||
// Если это последний канал в секвенсоре - увеличиваем счетчик буфера
|
||||
if (req_num == last_request)
|
||||
{
|
||||
hseq->buffer_count++;
|
||||
|
||||
if(hseq->buffer_count == hseq->buffer_size/2)
|
||||
{
|
||||
if (conf->BuffHalfCallback)
|
||||
{
|
||||
conf->BuffHalfCallback();
|
||||
}
|
||||
}
|
||||
if(hseq->buffer_count >= hseq->buffer_size)
|
||||
{
|
||||
// Кольцевой буфер
|
||||
if(conf->BufferCircular)
|
||||
hseq->buffer_count = 0;
|
||||
else
|
||||
ADC_SEQ_Stop(hadc, SEQ_Num);
|
||||
|
||||
if (conf->BuffFullCallback)
|
||||
{
|
||||
conf->BuffFullCallback();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Переход на Следующий канал
|
||||
req_num = (req_num+1)%numb_of_request;
|
||||
}
|
||||
|
||||
// Вызываем коллбек пользователя
|
||||
if (conf->SEQCpltCallback)
|
||||
{
|
||||
conf->SEQCpltCallback();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-- ADC Digital Comparators API functions -------------------------------------
|
||||
|
||||
|
||||
|
||||
//-- ADC GPIO functions --------------------------------------------------------
|
||||
/**
|
||||
* @brief Инициализация GPIO для ADC
|
||||
*/
|
||||
void adc_gpio_init(ADC_ChannelEnableTypeDef *ChEn)
|
||||
{
|
||||
#if (USE_ADC_SEQ0==1) || (USE_ADC_SEQ1==1) || (USE_ADC_DC0==1) || (USE_ADC_DC1==1) || (USE_ADC_DC2==1) || (USE_ADC_DC3==1)
|
||||
// Получаем структуру
|
||||
GPIO_Init_TypeDef *ch0_config = gpio_get_init(ADC_Ch0_GPIO_Port, ADC_Ch0_Pin);
|
||||
GPIO_Init_TypeDef *ch1_config = gpio_get_init(ADC_Ch1_GPIO_Port, ADC_Ch1_Pin);
|
||||
GPIO_Init_TypeDef *ch2_config = gpio_get_init(ADC_Ch2_GPIO_Port, ADC_Ch2_Pin);
|
||||
GPIO_Init_TypeDef *ch3_config = gpio_get_init(ADC_Ch3_GPIO_Port, ADC_Ch3_Pin);
|
||||
|
||||
if(ChEn->Ch0)
|
||||
{
|
||||
GPIO_StructInit(ch0_config);
|
||||
ch0_config->Pin = ADC_Ch0_Pin;
|
||||
GPIO_Init(ADC_Ch0_GPIO_Port, ch0_config);
|
||||
}
|
||||
if(ChEn->Ch1)
|
||||
{
|
||||
GPIO_StructInit(ch1_config);
|
||||
ch1_config->Pin = ADC_Ch1_Pin;
|
||||
GPIO_Init(ADC_Ch1_GPIO_Port, ch1_config);
|
||||
}
|
||||
if(ChEn->Ch2)
|
||||
{
|
||||
GPIO_StructInit(ch2_config);
|
||||
ch2_config->Pin = ADC_Ch2_Pin;
|
||||
GPIO_Init(ADC_Ch2_GPIO_Port, ch2_config);
|
||||
}
|
||||
if(ChEn->Ch3)
|
||||
{
|
||||
GPIO_StructInit(ch3_config);
|
||||
ch3_config->Pin = ADC_Ch3_Pin;
|
||||
GPIO_Init(ADC_Ch3_GPIO_Port, ch3_config);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
162
MDK-ARM/Core/App/adc.h
Normal file
162
MDK-ARM/Core/App/adc.h
Normal file
@@ -0,0 +1,162 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file adc.h
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер ADC на основе PLIB035.
|
||||
* Данный файл содержит определения типов, структур и прототипы функций
|
||||
* для работы с ADC, включая:
|
||||
* + Структуры и typedef для ADC
|
||||
* + Прототипы функций для инициализации и API драйвера
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
#ifndef __ADC_H
|
||||
#define __ADC_H
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
// Дефайны для пинов ADC
|
||||
#define ADC_Ch0_Pin GPIO_Pin_0 /**< PB0 — ADC Channel 0 */
|
||||
#define ADC_Ch0_GPIO_Port GPIOB /**< GPIO порт ADC Channel 0 */
|
||||
|
||||
#define ADC_Ch1_Pin GPIO_Pin_1 /**< PB1 — ADC Channel 1 */
|
||||
#define ADC_Ch1_GPIO_Port GPIOB /**< GPIO порт ADC Channel 1 */
|
||||
|
||||
#define ADC_Ch2_Pin GPIO_Pin_2 /**< PB2 — ADC Channel 2 */
|
||||
#define ADC_Ch2_GPIO_Port GPIOB /**< GPIO порт ADC Channel 2 */
|
||||
|
||||
#define ADC_Ch3_Pin GPIO_Pin_3 /**< PB3 — ADC Channel 3 */
|
||||
#define ADC_Ch3_GPIO_Port GPIOB /**< GPIO порт ADC Channel 3 */
|
||||
|
||||
|
||||
//-- Types ---------------------------------------------------------------------
|
||||
/**
|
||||
* @brief Типы callback-функций ADC
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
ADC_Callback_SeqCplt, /*!< Преобразование секвенсора завершено */
|
||||
ADC_Callback_BuffHalf, /*!< Буфер заполнен наполовину */
|
||||
ADC_Callback_BuffFull, /*!< Буфер заполнен полностью */
|
||||
ADC_Callback_DCTrig, /*!< Компаратор сработал */
|
||||
ADC_Callback_Error, /*!< Ошибка */
|
||||
}ADC_CallbackTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Типы callback-функций ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
unsigned Ch0:1; /*!< АЦП Канал 0 */
|
||||
unsigned Ch1:1; /*!< АЦП Канал 1 */
|
||||
unsigned Ch2:1; /*!< АЦП Канал 2 */
|
||||
unsigned Ch3:1; /*!< АЦП Канал 3 */
|
||||
}ADC_ChannelEnableTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Расширенная конфигурация секвенсора ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_SEQ_Init_TypeDef SEQ_Init; /* Стандартная конфигурация из PLIB */
|
||||
FunctionalState IT; /*!< Включить прерывания */
|
||||
uint8_t ITCount; /*!< Количество запросов для генерации прерывания */
|
||||
FunctionalState BufferCircular; /*!< Циклический буфер */
|
||||
|
||||
|
||||
void (*SEQCpltCallback)(void); /*!< Вызывается при завершении секвенсора */
|
||||
void (*BuffHalfCallback)(void); /*!< Вызывается при заполнении половины буфера */
|
||||
void (*BuffFullCallback)(void); /*!< Вызывается при заполнении буфера */
|
||||
void (*ErrorCallback)(); /*!< Вызывается при ошибке */
|
||||
}ADC_SEQ_ExtInit_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Расширенная конфигурация компаратора ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_DC_Init_TypeDef DC_Init;
|
||||
FunctionalState IT; /*!< Включить прерывания */
|
||||
|
||||
void (*DC_TrigCallback); /*!< Вызывается при срабатывании компаратора */
|
||||
void (*ErrorCallback)(); /*!< Вызывается при ошибке */
|
||||
}ADC_DC_ExtInit_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Хендл секвенсора ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_SEQ_ExtInit_TypeDef *Config; /*!< Конфигурации секвенсоров */
|
||||
|
||||
uint16_t *data_buffer; /*!< Указатель на буфер данных [ch][buffer_size]*/
|
||||
uint32_t buffer_size; /*!< Размер буфера (16-bit слова) */
|
||||
uint32_t buffer_count; /*!< Счетчик текущего индекса буфера */
|
||||
}ADC_SEQ_HandleTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Хендл компаратора ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_DC_ExtInit_TypeDef *Config; /*!< Конфигурации компараторов */
|
||||
}ADC_DC_HandleTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Хендл ADC
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
ADC_TypeDef *Instance; /*!< Регистры ADC */
|
||||
|
||||
ADC_SEQ_HandleTypeDef SEQ[ADC_SEQ_Total]; /*!< Хендл секвенсоров */
|
||||
ADC_DC_ExtInit_TypeDef DC[ADC_DC_Total]; /*!< Хендл компараторов */
|
||||
|
||||
/* ===== Channels ===== */
|
||||
ADC_ChannelEnableTypeDef *ChannelEnable; /*!< Какие каналы АЦП инициализировать (GPIO Pin) */
|
||||
uint16_t ChannelData[ADC_CH_Total]; /*!< Текущие значения каналов */
|
||||
}ADC_HandleTypeDef;
|
||||
//-- External handles ----------------------------------------------------------
|
||||
extern ADC_HandleTypeDef hadc;
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
/* Первичная инициализация ADC */
|
||||
void adc_init_first(void);
|
||||
void adc_gpio_init(ADC_ChannelEnableTypeDef *ChEn);
|
||||
|
||||
/* ADC API functions */
|
||||
|
||||
/* Записать калибровочные значения канала */
|
||||
OperationStatus ADC_Channel_Calibr(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel, int OFFSET, int GAIN);
|
||||
/* Получение текущего значения канала */
|
||||
uint16_t ADC_Channel_GetValue(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel);
|
||||
|
||||
/* Sequencer Init functions*/
|
||||
|
||||
/* Инициализация секвенсора АЦП */
|
||||
OperationStatus adc_seq_init(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_ExtInit_TypeDef *NewConfig);
|
||||
/* Обработчик прерываний секвенсора */
|
||||
void adc_seq_irq_handler(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num);
|
||||
|
||||
/* Sequencer API functions */
|
||||
|
||||
/* Установка коллбека секвенсора АЦП */
|
||||
OperationStatus ADC_SEQ_Set_Callback(ADC_HandleTypeDef* hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_CallbackTypeDef CallbackType, void (*Callback)(void));
|
||||
|
||||
/* Запуск секвенсора АЦП с буфером */
|
||||
OperationStatus ADC_SEQ_Start(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num, uint16_t (*data_buffer)[], uint32_t buffer_size);
|
||||
/* Остановка секвенсора АЦП */
|
||||
OperationStatus ADC_SEQ_Stop(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num);
|
||||
|
||||
/* Программный запуск преобразования секвенсора */
|
||||
void ADC_SEQ_SoftwareStart(void);
|
||||
|
||||
|
||||
|
||||
|
||||
/* Comparator API functions*/
|
||||
|
||||
void adc_dc_handler(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num);
|
||||
#endif /*__ADC_H*/
|
||||
417
MDK-ARM/Core/App/gpio.c
Normal file
417
MDK-ARM/Core/App/gpio.c
Normal file
@@ -0,0 +1,417 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file gpio.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер GPIO на основе PLIB035.
|
||||
* Этот файл содержит:
|
||||
* + Инициализацию портов GPIOA и GPIOB
|
||||
* + Функции для работы со светодиодами:
|
||||
* - Инициализацию структуры светодиода
|
||||
* - Включение, выключение, переключение светодиода
|
||||
* - Динамические режимы: моргание и плавное затухание
|
||||
* + Функции для работы с кнопками:
|
||||
* - Инициализацию структуры кнопки
|
||||
* - Чтение состояния кнопки с защитой от дребезга
|
||||
* + Утилитарные функции для получения конфигурации пинов
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Использование этого драйвера предполагает наличие корректных настроек:
|
||||
* - Определены массивы конфигурации gpioa_config и gpiob_config в periph_config.h
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот драйвер #####
|
||||
==============================================================================
|
||||
|
||||
1. Настройка периферии (periph_config.h):
|
||||
(+) Определить массивы GPIO_Init_TypeDef для портов:
|
||||
gpioa_config[32], gpiob_config[32]
|
||||
(+) Настроить режим пинов: Input, Output, AltFunc или не используется (аналог режим)
|
||||
|
||||
2. Инициализация GPIO:
|
||||
(+) gpio_init() — инициализация портов GPIOA и GPIOB
|
||||
|
||||
3. Работа со светодиодами:
|
||||
(+) GPIO_LED_Init(&led, GPIOA, GPIO_PIN_5, SET) — инициализация светодиода
|
||||
(+) GPIO_LED_On(&led) — включение светодиода
|
||||
(+) GPIO_LED_Off(&led) — выключение светодиода
|
||||
(+) GPIO_LED_Toggle(&led) — переключение светодиода
|
||||
(+) GPIO_LED_Blink_Start(&led, 500) — запуск моргания (период 500 мс)
|
||||
(+) GPIO_LED_Fading_Start(&led, 1000) — запуск плавного затухания (период 1 секунда)
|
||||
(+) GPIO_LED_Dynamic_Handle(&led) — обработка динамических режимов в основном цикле
|
||||
|
||||
4. Работа с кнопками:
|
||||
(+) GPIO_Switch_Init(&sw, GPIOB, GPIO_PIN_0, SET) — инициализация кнопки
|
||||
(+) GPIO_Read_Switch(&sw) — чтение состояния кнопки с фильтрацией
|
||||
|
||||
5. Получение конфигурации пинов:
|
||||
(+) gpio_get_init(порт, пин) - для периферии
|
||||
|
||||
==============================================================================
|
||||
##### Особенности работы #####
|
||||
==============================================================================
|
||||
|
||||
- Динамические режимы светодиодов:
|
||||
- Моргание: простой on/off с заданным периодом
|
||||
- Плавное затухание: квадратичное изменение яркости через ШИМ
|
||||
- Требуют вызова GPIO_LED_Dynamic_Handle() в основном цикле
|
||||
|
||||
- Защита от дребезга:
|
||||
- Фильтрация по времени (Sw_FilterDelay в миллисекундах)
|
||||
- Неблокирующий алгоритм с отслеживанием состояния
|
||||
- При изменении уровня запускается таймер, состояние обновляется после задержки
|
||||
|
||||
- ШИМ для плавного затухания:
|
||||
- Программная генерация с 15 уровнями яркости (LED_PWM_TICKS)
|
||||
- Полный цикл затухания-разтухания: 2 × LED_PWM_TICKS шагов
|
||||
|
||||
- Конфигурация пинов:
|
||||
- Периферия может перезаписывать конфигурацию пинов (например, UART на AltFunc)
|
||||
- gpio_get_init() позволяет периферии получить исходную конфигурацию
|
||||
- После использования периферии можно восстановить исходные настройки
|
||||
|
||||
- Табличный подход:
|
||||
- Каждый пин имеет свою строку в массиве конфигурации
|
||||
- Позволяет централизованно управлять всеми пинами
|
||||
- Упрощает отладку и модификацию конфигурации
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "periph_config.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
//-- GPIO init functions -------------------------------------------------------
|
||||
void gpio_init(void)
|
||||
{
|
||||
RCU_AHBClkCmd(RCU_AHBClk_GPIOA, ENABLE);
|
||||
RCU_AHBRstCmd(RCU_AHBRst_GPIOA, ENABLE);
|
||||
RCU_AHBClkCmd(RCU_AHBClk_GPIOB, ENABLE);
|
||||
RCU_AHBRstCmd(RCU_AHBRst_GPIOB, ENABLE);
|
||||
|
||||
/* Сброс пинов */
|
||||
GPIO_DeInit(GPIOA);
|
||||
GPIO_DeInit(GPIOB);
|
||||
|
||||
// Инициализация порта A
|
||||
for (int i = 0; i < sizeof(gpioa_config) / sizeof(gpioa_config[0]); i++)
|
||||
{
|
||||
GPIO_Init(GPIOA, &gpioa_config[i]);
|
||||
}
|
||||
|
||||
// Инициализация порта B
|
||||
for (int i = 0; i < sizeof(gpiob_config) / sizeof(gpiob_config[0]); i++)
|
||||
{
|
||||
GPIO_Init(GPIOB, &gpiob_config[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
GPIO_Init_TypeDef *gpio_get_init(GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin)
|
||||
{
|
||||
uint8_t pin_index = (31 - __CLZ(GPIO_Pin & -GPIO_Pin));
|
||||
|
||||
if (GPIOx == GPIOA)
|
||||
{
|
||||
// Проверяем границы массива
|
||||
if (pin_index < sizeof(gpioa_config) / sizeof(gpioa_config[0]))
|
||||
{
|
||||
return &gpioa_config[pin_index];
|
||||
}
|
||||
}
|
||||
else if (GPIOx == GPIOB)
|
||||
{
|
||||
// У тебя была опечатка: возвращал gpioa_config вместо gpiob_config
|
||||
if (pin_index < sizeof(gpiob_config) / sizeof(gpiob_config[0]))
|
||||
{
|
||||
return &gpiob_config[pin_index];
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//-- GPIO LED functions --------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Инициализировать светодиод (структуру светодиода)
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @param GPIOx Указатель на структуру порта для светодиода
|
||||
* @param GPIO_PIN_X Пин для светодиода
|
||||
* @param LED_ActiveLevel Состояния пина, при котором светодиод будет включен
|
||||
*/
|
||||
OperationStatus GPIO_LED_Init(GPIO_LEDTypeDef *led, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, BitState LED_ActiveLevel)
|
||||
{
|
||||
if(!led || !GPIOx ||!GPIO_PIN_X)
|
||||
return ERROR;
|
||||
|
||||
led->LED_Port = GPIOx;
|
||||
led->LED_Pin = GPIO_PIN_X;
|
||||
led->LED_ActiveLvl = LED_ActiveLevel;
|
||||
|
||||
GPIO_LED_Off(led);
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Включить светодиод
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @return Operation Status
|
||||
*/
|
||||
OperationStatus GPIO_LED_On(GPIO_LEDTypeDef *led)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
led->state = LED_IS_ON;
|
||||
GPIO_WriteBit(led->LED_Port, led->LED_Pin, led->LED_ActiveLvl);
|
||||
|
||||
|
||||
return OK;
|
||||
}
|
||||
/**
|
||||
* @brief Выключить светодиод
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @return Operation Status
|
||||
*/
|
||||
OperationStatus GPIO_LED_Off(GPIO_LEDTypeDef *led)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
led->state = LED_IS_OFF;
|
||||
BitState offstate = (led->LED_ActiveLvl == SET)? CLEAR: SET;
|
||||
GPIO_WriteBit(led->LED_Port, led->LED_Pin, offstate);
|
||||
|
||||
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Переключить светодиод
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @return Operation Status
|
||||
*/
|
||||
OperationStatus GPIO_LED_Toggle(GPIO_LEDTypeDef *led)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
|
||||
if(led->state == LED_IS_ON || led->state == LED_IS_OFF)
|
||||
{
|
||||
if(led->state == LED_IS_OFF)
|
||||
led->state = LED_IS_ON;
|
||||
else
|
||||
led->state = LED_IS_OFF;
|
||||
|
||||
GPIO_ToggleBits(led->LED_Port, led->LED_Pin);
|
||||
return OK;
|
||||
}
|
||||
else
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Выставить светодиод по переменной
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @param led_state Состояние светодиода
|
||||
* @return Operation Status
|
||||
*/
|
||||
OperationStatus GPIO_LED_Set(GPIO_LEDTypeDef *led, uint8_t led_state)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
if(led_state)
|
||||
{
|
||||
return GPIO_LED_On(led);
|
||||
}
|
||||
else
|
||||
{
|
||||
return GPIO_LED_Off(led);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @brief Активировать моргание светодиодом
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @param period Период плавного моргания светодиода
|
||||
* @return Operation Status
|
||||
* @details Функция ставит режим моргания, который после управляется в @ref GPIO_LED_Dynamic_Handle
|
||||
*/
|
||||
OperationStatus GPIO_LED_Blink_Start(GPIO_LEDTypeDef *led, uint32_t period)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
led->state = LED_IS_BLINKING;
|
||||
led->LED_Period = period;
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Активировать моргание светодиодом
|
||||
* @param led Указатель на структуру светодиода
|
||||
* @param period Период плавного моргания светодиода
|
||||
* @return Operation Status
|
||||
* @details Функция ставит режим моргания, который после управляется в @ref GPIO_LED_Dynamic_Handle
|
||||
*/
|
||||
OperationStatus GPIO_LED_Fading_Start(GPIO_LEDTypeDef *led, uint32_t period)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return ERROR;
|
||||
|
||||
led->state = LED_IS_FADING;
|
||||
led->LED_Period = period;
|
||||
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
//uint8_t LED_PWM_FADING_DUTYS[LED_PWM_TICKS] = {0 1 2 3 4 5 6 7 8 9 10 11 12 }
|
||||
/**
|
||||
* @brief Управление динамическими режимами свечения светодиода
|
||||
* @param Указатель на структуру светодиода
|
||||
* @details Функция моргает/плавно моргает светодиодом в неблокирующем режиме
|
||||
* Т.е. функцию надо вызывать постоянно, чтобы она мониторила тики
|
||||
* и в нужный момент переключала светодиод
|
||||
*/
|
||||
void GPIO_LED_Dynamic_Handle(GPIO_LEDTypeDef *led)
|
||||
{
|
||||
if(!led || !led->LED_Port || !led->LED_Pin)
|
||||
return;
|
||||
|
||||
/* Режим моргания светодиода */
|
||||
if(led->state == LED_IS_BLINKING)
|
||||
{
|
||||
uint32_t tickcurrent = millis();
|
||||
/* Ожидание истечения периода моргания */
|
||||
if((tickcurrent - led->tickprev) > led->LED_Period)
|
||||
{
|
||||
/* Моргание */
|
||||
GPIO_ToggleBits(led->LED_Port, led->LED_Pin);
|
||||
|
||||
led->tickprev = tickcurrent;
|
||||
}
|
||||
}
|
||||
/* Режим плавного моргания светодиода */
|
||||
else if(led->state == LED_IS_FADING)
|
||||
{
|
||||
static unsigned direction = 0;
|
||||
static int duty = 0;
|
||||
uint32_t tickcurrent = millis();
|
||||
/* Ожидание момента изменения яркости */
|
||||
/* Период ШИМ 20 мс, поэтому менять яроксть надо 40 раз за период (туда обратно) */
|
||||
if((tickcurrent - led->tickprev) > led->LED_Period/(LED_PWM_TICKS*2))
|
||||
{
|
||||
/* Формирование разтухания */
|
||||
if(direction == 0)
|
||||
{
|
||||
if(++duty >= LED_PWM_TICKS)
|
||||
{
|
||||
direction = 1;
|
||||
duty = LED_PWM_TICKS;
|
||||
}
|
||||
}
|
||||
/* Формирование затухания */
|
||||
else
|
||||
{
|
||||
if(--duty <= 0)
|
||||
{
|
||||
direction = 0;
|
||||
duty = 0;
|
||||
}
|
||||
}
|
||||
led->tickprev = tickcurrent;
|
||||
}
|
||||
/* Формирование ШИМ для изменения яркости */
|
||||
int duty_crt = (duty*duty/LED_PWM_TICKS);
|
||||
if(tickcurrent%LED_PWM_TICKS < duty_crt)
|
||||
{
|
||||
GPIO_WriteBit(led->LED_Port, led->LED_Pin, led->LED_ActiveLvl);
|
||||
}
|
||||
else
|
||||
{
|
||||
BitState offstate = (led->LED_ActiveLvl == SET)? CLEAR: SET;
|
||||
GPIO_WriteBit(led->LED_Port, led->LED_Pin, offstate);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//-- GPIO Switch functions -----------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Инициализировать кнопку (структуру кнопки)
|
||||
* @param sw Указатель на структуру кнопки
|
||||
* @param GPIOx Указатель на структуру порта для кнопки
|
||||
* @param GPIO_PIN_X Пин для кнопки
|
||||
* @param SW_ActiveLevel Состояния пина, когда кнопка нажата
|
||||
* @return Operation Status
|
||||
*/
|
||||
OperationStatus GPIO_Switch_Init(GPIO_SwitchTypeDef *sw, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, BitState SW_ActiveLevel)
|
||||
{
|
||||
if(!sw || !GPIOx || !GPIO_PIN_X)
|
||||
return ERROR;
|
||||
|
||||
sw->Sw_Port = GPIOx;
|
||||
sw->Sw_Pin = GPIO_PIN_X;
|
||||
sw->Sw_ActiveLvl = SW_ActiveLevel;
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Считать состоянии кнопки
|
||||
* @param sw Указатель на структуру кнопки
|
||||
* @return 1 - если кнопка нажата,
|
||||
* 0 - если отжата,
|
||||
* -1 - если ошибка
|
||||
* @details Функция включает в себя неблокирующую проверку на дребезг
|
||||
* Т.е. функцию надо вызывать постоянно, чтобы она мониторила состояние кнопки
|
||||
*/
|
||||
int GPIO_Read_Switch(GPIO_SwitchTypeDef *sw)
|
||||
{
|
||||
if(!sw || !sw->Sw_Port || !sw->Sw_Pin)
|
||||
return -1;
|
||||
|
||||
int current_level = (GPIO_ReadBit(sw->Sw_Port, sw->Sw_Pin) == sw->Sw_ActiveLvl);
|
||||
|
||||
if(sw->Sw_FilterDelay) // если включена защита от дребезга
|
||||
{
|
||||
// Если таймер не запущен и состояние изменилось - запускаем таймер
|
||||
if(sw->tickprev == 0 && current_level != sw->Sw_CurrentState)
|
||||
{
|
||||
sw->tickprev = millis();
|
||||
}
|
||||
|
||||
// Если таймер запущен
|
||||
if(sw->tickprev != 0)
|
||||
{
|
||||
// Проверяем, прошел ли достаточный интервал для фильтрации
|
||||
if((millis() - sw->tickprev) >= sw->Sw_FilterDelay)
|
||||
{
|
||||
// Обновляем состояние только если оно все еще отличается
|
||||
if(current_level != sw->Sw_CurrentState)
|
||||
{
|
||||
sw->Sw_CurrentState = current_level;
|
||||
}
|
||||
// Останавливаем таймер в любом случае
|
||||
sw->tickprev = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else // если нет защиты от дребезга
|
||||
{
|
||||
sw->Sw_CurrentState = current_level;
|
||||
}
|
||||
return sw->Sw_CurrentState;
|
||||
}
|
||||
164
MDK-ARM/Core/App/gpio.h
Normal file
164
MDK-ARM/Core/App/gpio.h
Normal file
@@ -0,0 +1,164 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file gpio.h
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер GPIO на основе PLIB035.
|
||||
* Данный файл содержит определения типов, структур и прототипы функций
|
||||
* для работы с UART, включая:
|
||||
* + Структуры и typedef для работы с кнопками и светодиодами
|
||||
* + Макросы для конфигурации режима пинов
|
||||
* + Прототипы функций для инициализации и API драйвера
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
#ifndef __GPIO_H
|
||||
#define __GPIO_H
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
// Дефайны для режима пина OutEnable, AltFuncEnable, DigitalEnable
|
||||
#define GPIO_PinMode_Unused DISABLE, DISABLE, DISABLE
|
||||
#define GPIO_PinMode_Input DISABLE, DISABLE, ENABLE
|
||||
#define GPIO_PinMode_Output ENABLE, DISABLE, ENABLE
|
||||
#define GPIO_PinMode_AltFunc DISABLE, ENABLE, ENABLE
|
||||
|
||||
#ifndef LED_PWM_TICKS
|
||||
#define LED_PWM_TICKS 15 ///< Количество тиков в периоде ШИМ
|
||||
#endif
|
||||
//-- Types ---------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Режимы работы светодиода
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
LED_IS_OFF = 0, ///< Светодиод выключен
|
||||
LED_IS_ON = 1, ///< Светодиод включен
|
||||
LED_IS_BLINKING = 2, ///< Моргание светодиодом
|
||||
LED_IS_FADING = 3, ///< Плавное моргание светодиодом
|
||||
}GPIO_LEDStateTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура светодиода
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
GPIO_LEDStateTypeDef state; ///< Текущий режим работы светодиода
|
||||
|
||||
GPIO_TypeDef *LED_Port; ///< GPIO порт ножки светодиода
|
||||
uint32_t LED_Pin; ///< GPIO пин ножки светодиода
|
||||
|
||||
BitState LED_ActiveLvl; ///< Активный уровень ножки (при котором светодиод горит)
|
||||
uint32_t LED_Period; ///< Период моргания светодиода
|
||||
|
||||
uint32_t tickprev;
|
||||
}GPIO_LEDTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура кнопки
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
GPIO_TypeDef *Sw_Port; ///< GPIO порт ножки кнопки
|
||||
uint32_t Sw_Pin; ///< GPIO пин ножки кнопки
|
||||
|
||||
BitState Sw_ActiveLvl; ///< Активный уровень ножки (при котором кнопка нажата)
|
||||
uint32_t Sw_CurrentState; ///< Текущее состояние кнопки
|
||||
uint32_t Sw_FilterDelay; ///< Фильтр от дребезга (в мс)
|
||||
|
||||
uint32_t tickprev;
|
||||
}GPIO_SwitchTypeDef;
|
||||
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
|
||||
/* Init functions */
|
||||
|
||||
void gpio_init(void);
|
||||
GPIO_Init_TypeDef *gpio_get_init(GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin);
|
||||
|
||||
|
||||
/* API functions*/
|
||||
|
||||
/**
|
||||
* @addtogroup GPIO_SWITCH Switch tools
|
||||
* @brief Функции для работы с GPIO, как с кнопкой
|
||||
* @par Пример использования:
|
||||
@code
|
||||
MX_GPIO_Init(); // инициализация пина аппаратная
|
||||
|
||||
// Инициализация кнопки на порте GPIOB, пин 0, активный уровень 1
|
||||
GPIO_SwitchTypeDef sw1;
|
||||
GPIO_Switch_Init(&sw1, GPIOB, GPIO_PIN_0, 1); // или дефайн SW_ON/SW_OFF
|
||||
|
||||
// Считываем состояние кнопки
|
||||
if(GPIO_Read_Switch(&sw1))
|
||||
{
|
||||
// Кнопка нажата
|
||||
LED_ON();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Кнопка отжата
|
||||
LED_OFF();
|
||||
}
|
||||
@endcode
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Инициализировать кнопку (структуру кнопки) */
|
||||
OperationStatus GPIO_Switch_Init(GPIO_SwitchTypeDef *sw, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, BitState SW_On_State);
|
||||
/* Считать состоянии кнопки запуска */
|
||||
int GPIO_Read_Switch(GPIO_SwitchTypeDef *swstart);
|
||||
|
||||
/** GPIO_SWITCH
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup GPIO_LEDS LED tools
|
||||
* @brief Функции для работы с GPIO, для управления светодиодом
|
||||
* @par Пример использования:
|
||||
@code
|
||||
// Инициализация светодиода на порте GPIOA, пин 5, активный уровень 0
|
||||
GPIO_LEDTypeDef led;
|
||||
GPIO_LED_Init(&led, GPIOA, GPIO_PIN_5, 0); // или дефайн LED_ON/LED_OFF
|
||||
|
||||
// Включение светодиода
|
||||
GPIO_LED_On(&led);
|
||||
|
||||
// Запуск моргания
|
||||
GPIO_LED_Blink_Start(&led, 500); // Период 500 мс
|
||||
|
||||
// В основном цикле
|
||||
while (1) {
|
||||
GPIO_LED_Dynamic_Handle(&led);
|
||||
}
|
||||
@endcode
|
||||
* @{
|
||||
*/
|
||||
|
||||
/* Инициализировать светодиод (структуру светодиода) */
|
||||
OperationStatus GPIO_LED_Init(GPIO_LEDTypeDef *led, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, BitState LED_On_State);
|
||||
/* Включить светодиод */
|
||||
OperationStatus GPIO_LED_On (GPIO_LEDTypeDef *led);
|
||||
/* Выключить светодиод */
|
||||
OperationStatus GPIO_LED_Off (GPIO_LEDTypeDef *led);
|
||||
/* Переключить светодиод */
|
||||
OperationStatus GPIO_LED_Toggle(GPIO_LEDTypeDef *led);
|
||||
/* Выставить светодиод по переменной */
|
||||
OperationStatus GPIO_LED_Set (GPIO_LEDTypeDef *led, uint8_t led_state);
|
||||
/* Активировать моргание светодиодом */
|
||||
OperationStatus GPIO_LED_Blink_Start (GPIO_LEDTypeDef *led, uint32_t period);
|
||||
/* Активировать моргание светодиодом */
|
||||
OperationStatus GPIO_LED_Fading_Start(GPIO_LEDTypeDef *led, uint32_t period);
|
||||
/* Управление динамическими режимами свечения светодиода */
|
||||
void GPIO_LED_Dynamic_Handle(GPIO_LEDTypeDef *led);
|
||||
|
||||
/** GPIO_LEDS
|
||||
* @}
|
||||
*/
|
||||
#endif /*__GPIO_H*/
|
||||
104
MDK-ARM/Core/App/main.c
Normal file
104
MDK-ARM/Core/App/main.c
Normal file
@@ -0,0 +1,104 @@
|
||||
/*==============================================================================
|
||||
* Шаблон проекта для К1921ВК035 с использованием бибилотеки PLIB035
|
||||
*------------------------------------------------------------------------------
|
||||
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
|
||||
*==============================================================================
|
||||
* ЦНИИ СЭТ
|
||||
*==============================================================================
|
||||
*/
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "main.h"
|
||||
|
||||
void restart_receive(void);
|
||||
void heartbit(void);
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
uint8_t rxbuff[10] = {0};
|
||||
uint8_t txbuff[20] = {0};
|
||||
uint16_t seq0_buff[2][100] = {0};
|
||||
uint16_t seq1_buff[2][100] = {0};
|
||||
//-- Peripheral init functions -------------------------------------------------
|
||||
void periph_init()
|
||||
{
|
||||
sysclk_init();
|
||||
uart_init_first();
|
||||
adc_init_first();
|
||||
tmr_init_first();
|
||||
gpio_init();
|
||||
#ifdef RETARGET
|
||||
retarget_init();
|
||||
#endif
|
||||
NVIC_SetAllPriorities();
|
||||
printf("\nAll peripherals inited, SYSCLK = %3d MHz\n", (int)(SystemCoreClock / 1E6));
|
||||
|
||||
|
||||
UART_Start(&huart1, UART_FIFOLevel_1_8, UART_FIFOLevel_1_8);
|
||||
|
||||
// TMR_Set_Callback(&htmr2, TMR_Callback_Update, &heartbit);
|
||||
TMR_Start(&htmr0, DISABLE);
|
||||
TMR_Start(&htmr1, DISABLE);
|
||||
TMR_Start(&htmr2, ENABLE);
|
||||
ADC_SEQ_Set_Callback(&hadc, ADC_SEQ_Num_1, ADC_Callback_SeqCplt, &heartbit);
|
||||
// ADC_SEQ_Start(&hadc, ADC_SEQ_Num_0, seq0_buff, 100);
|
||||
ADC_SEQ_Start(&hadc, ADC_SEQ_Num_1, NULL, 100);
|
||||
}
|
||||
|
||||
//-- Main ----------------------------------------------------------------------
|
||||
uint32_t startmillis = 0;
|
||||
uint32_t prev_tick;
|
||||
int main()
|
||||
{
|
||||
periph_init();
|
||||
|
||||
// UART_Receive_IT(&huart1, rxbuff, sizeof(rxbuff));
|
||||
TMR_Delay_Start(&htmr0, &prev_tick);
|
||||
ADC_SEQ_SoftwareStart();
|
||||
while (1) {
|
||||
if(TMR_Delay_Done(&htmr0, 2000000, &prev_tick))
|
||||
{
|
||||
TMR_Delay_Start(&htmr0, &prev_tick);
|
||||
GPIO_ToggleBits(GPIOA, GPIO_Pin_8);
|
||||
startmillis = millis();
|
||||
// ADC_SEQ_SoftwareStart();
|
||||
}
|
||||
TMR_Delay(&htmr0, 100000);
|
||||
// GPIO_ToggleBits(GPIOA, GPIO_Pin_7);
|
||||
// UART_Transmit_IT(&huart1, (uint8_t*)"Hello World: ", sizeof("Hello World: ")-1);
|
||||
// int len = sprintf((char*)txbuff, "\r\nValue: %d", ADC_Channel_GetValue(&hadc, ADC_CH_Num_3));
|
||||
// UART_Transmit_IT(&huart1, txbuff, len);
|
||||
};
|
||||
//return 0;
|
||||
}
|
||||
|
||||
void restart_receive(void)
|
||||
{
|
||||
// UART_Receive_IT(&huart1, rxbuff, sizeof(rxbuff));
|
||||
// UART_Transmit_IT(&huart1, rxbuff, sizeof(rxbuff));
|
||||
}
|
||||
|
||||
char tickbuff[40] = {0};
|
||||
void heartbit(void)
|
||||
{
|
||||
static uint32_t prev_tick = 0;
|
||||
int len = sprintf(tickbuff, "\r\nTick: %d, Value: %d", TMR_Get_Cnt(&htmr0) - prev_tick, ADC_Channel_GetValue(&hadc, ADC_CH_Num_3));
|
||||
prev_tick = TMR_Get_Cnt(&htmr0);
|
||||
UART_Transmit_IT(&huart1, (uint8_t *)tickbuff, len);
|
||||
}
|
||||
|
||||
//-- Assert --------------------------------------------------------------------
|
||||
void Error_Handler(void)
|
||||
{
|
||||
__disable_irq();
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
#if defined USE_FULL_ASSERT
|
||||
void assert_failed(uint8_t* file, uint32_t line)
|
||||
{
|
||||
printf("Assert failed: file %s on line %d\n", file, (int)line);
|
||||
while (1) {
|
||||
};
|
||||
}
|
||||
#endif /* USE_FULL_ASSERT */
|
||||
25
MDK-ARM/Core/App/main.h
Normal file
25
MDK-ARM/Core/App/main.h
Normal file
@@ -0,0 +1,25 @@
|
||||
/*==============================================================================
|
||||
* Шаблон проекта для К1921ВК035 с использованием бибилотеки PLIB035
|
||||
*------------------------------------------------------------------------------
|
||||
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
|
||||
*==============================================================================
|
||||
* ЦНИИ СЭТ
|
||||
*==============================================================================
|
||||
*/
|
||||
#ifndef __MAIN_H
|
||||
#define __MAIN_H
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "periph_config.h"
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
#include "mylibs_include.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
//-- Exported variables --------------------------------------------------------
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
void Error_Handler(void);
|
||||
|
||||
#endif /* __MAIN_H */
|
||||
316
MDK-ARM/Core/App/sysclk.c
Normal file
316
MDK-ARM/Core/App/sysclk.c
Normal file
@@ -0,0 +1,316 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file sysclk.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер тактирования системы на основе PLIB035.
|
||||
* Этот файл содержит:
|
||||
* + Инициализацию системного тактирования (PLL, осцилляторы)
|
||||
* + Настройку частоты ядра и периферии
|
||||
* + Управление системным таймером (SysTick)
|
||||
* + Функции для работы со временем (millis, micros)
|
||||
* + Систему периодических коллбеков
|
||||
* + Настройку тактирования периферии
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Этот драйвер должен быть инициализирован ПЕРВЫМ в программе, до любой другой периферии.
|
||||
* Неправильная настройка тактирования может привести к неработоспособности всего МК.
|
||||
*
|
||||
* Использование этого драйвера предполагает наличие корректных настроек:
|
||||
* - Определены константы SYSCLK_CORE_CLOCK_MHZ и SYSCLK_Oscil_Type в periph_config.h
|
||||
* - Определен тип системного тика SYSCLK_TickType в periph_config.h
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот драйвер #####
|
||||
==============================================================================
|
||||
|
||||
1. Настройка в periph_config.h:
|
||||
(+) SYSCLK_CORE_CLOCK_MHZ - частота ядра в МГц (например, 100)
|
||||
(+) SYSCLK_Oscil_Type - источник тактирования (RCU_Oscil_OSE или RCU_Oscil_OSI)
|
||||
(+) SYSCLK_TickType - период системного тика (от SYSCLK_Tick_1us до SYSCLK_Tick_100ms)
|
||||
|
||||
2. Инициализация (в начале main()):
|
||||
(+) sysclk_init() - настраивает PLL, SysTick и счетчики времени
|
||||
(+) В SysTick_Handler() вызвать sysclk_irq_handler()
|
||||
|
||||
3. Работа со временем:
|
||||
(+) millis() - текущее время в миллисекундах (переполнение через 49 дней)
|
||||
(+) micros() - текущее время в микросекундах (точность зависит от SYSCLK_TickType)
|
||||
|
||||
4. Периодические задачи:
|
||||
(+) SYSCLK_Set_Callback(func, period_ms) - регистрация функции для периодического вызова
|
||||
(+) Максимум 16 функций, период должен быть >= периода системного тика
|
||||
|
||||
5. Настройка тактирования периферии:
|
||||
(+) rcu_set_clock_adc(source, freq_mhz, enable) - для АЦП
|
||||
(+) Частота АЦП не должна превышать 12.5 МГц согласно datasheet
|
||||
|
||||
==============================================================================
|
||||
##### Особенности работы #####
|
||||
==============================================================================
|
||||
|
||||
- Выбор SYSCLK_TickType влияет на:
|
||||
- Точность micros() (при 1ms тике micros() дает значения с шагом 1000)
|
||||
- Нагрузку на ЦП (1us = 1М прерываний в секунду, 100ms = 10 прерываний в секунду)
|
||||
- Минимальный период коллбеков (не может быть меньше SYSCLK_TickType)
|
||||
|
||||
- При настройке PLL:
|
||||
- Драйвер автоматически подбирает делители для заданной частоты
|
||||
- Если частота недостижима - вызовется Error_Handler()
|
||||
- Всегда проверяйте supported frequencies в datasheet
|
||||
|
||||
- Коллбеки выполняются в контексте прерывания SysTick:
|
||||
- Не должны выполняться долго
|
||||
- Не должны вызывать блокирующие функции
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
/* Includes ------------------------------------------------------------------*/
|
||||
#include "periph_config.h"
|
||||
|
||||
/* Private variables ---------------------------------------------------------*/
|
||||
/** @brief Счетчик миллисекунд */
|
||||
__IO uint32_t msTick = 0;
|
||||
|
||||
/** @brief Счетчик микросекунд */
|
||||
__IO uint32_t usTick = 0;
|
||||
|
||||
/** @brief Инкремент для миллисекунд */
|
||||
static __IO uint32_t msTickInc = 0;
|
||||
|
||||
/** @brief Инкремент для микросекунд */
|
||||
static __IO uint32_t usTickInc = 0;
|
||||
|
||||
/** @brief Обработчик системных коллбеков */
|
||||
static SYSCLK_CallbackHandleTypeDef hsyscb = {0};
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
|
||||
//-- Private function prototypes -----------------------------------------------
|
||||
static inline void millis_inc(void);
|
||||
static inline void micros_inc(void);
|
||||
|
||||
//-- Peripheral init functions -------------------------------------------------
|
||||
/**
|
||||
* @brief Инициализация системного тактирования.
|
||||
* @details Настраивает PLL, SysTick и счетчики времени.
|
||||
* Должна быть вызвана первой в функции main().
|
||||
*/
|
||||
void sysclk_init(void)
|
||||
{
|
||||
OperationStatus status;
|
||||
status = RCU_PLL_AutoConfig(SYSCLK_CORE_CLOCK_MHZ*__MHZ, SYSCLK_Oscil_Type);
|
||||
if (status == ERROR)
|
||||
{
|
||||
Error_Handler();
|
||||
}
|
||||
SystemCoreClockUpdate();
|
||||
// RCU_ClkOutConfig(RCU_SysPeriphClk_PLLClk, 1, ENABLE);
|
||||
// RCU_ClkOutCmd(ENABLE);
|
||||
|
||||
SysTick_Config(SYSCLK_CORE_CLOCK_MHZ*__MHZ/SYSCLK_TickType);
|
||||
switch(SYSCLK_TickType)
|
||||
{
|
||||
case SYSCLK_Tick_1us:
|
||||
usTickInc = 1;
|
||||
msTickInc = 1;
|
||||
break;
|
||||
case SYSCLK_Tick_10us:
|
||||
usTickInc = 10;
|
||||
msTickInc = 1;
|
||||
break;
|
||||
case SYSCLK_Tick_100us:
|
||||
usTickInc = 100;
|
||||
msTickInc = 1;
|
||||
break;
|
||||
case SYSCLK_Tick_1ms:
|
||||
usTickInc = 1000;
|
||||
msTickInc = 1;
|
||||
break;
|
||||
case SYSCLK_Tick_10ms:
|
||||
usTickInc = 10000;
|
||||
msTickInc = 10;
|
||||
break;
|
||||
case SYSCLK_Tick_100ms:
|
||||
usTickInc = 100000;
|
||||
msTickInc = 100;
|
||||
break;
|
||||
default:
|
||||
/* Должен быть определен в periph_config.h */
|
||||
Error_Handler();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Общий обработчик прерываний SysClock
|
||||
* @details Обрабатывает мс и мкс и вызывает коллбеки
|
||||
*/
|
||||
void sysclk_irq_handler(void)
|
||||
{
|
||||
static uint32_t usAccumulator = 0; // Накопитель мкс
|
||||
/* Инкремент микросекунд */
|
||||
micros_inc();
|
||||
|
||||
if(msTickInc == 1)
|
||||
{
|
||||
/* Аккумулятивный метод для миллисекунд (без деления) */
|
||||
usAccumulator += usTickInc;
|
||||
if (usAccumulator >= 1000) {
|
||||
millis_inc();
|
||||
usAccumulator -= 1000; // Вычитание быстрее деления
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
millis_inc();
|
||||
}
|
||||
|
||||
/* Вызов зарегистрированных коллбеков */
|
||||
for(int i = 0; i < hsyscb.CallbackInUse; i++)
|
||||
{
|
||||
if(hsyscb.Callback[i] != NULL)
|
||||
{
|
||||
/* Проверка истекшего времени */
|
||||
uint32_t elapsed = msTick - hsyscb.CallbackPrevMs[i];
|
||||
if(elapsed >= hsyscb.CallbackPeriod[i])
|
||||
{
|
||||
/* Обновление времени последнего вызова и вызов коллбека */
|
||||
hsyscb.CallbackPrevMs[i] = msTick;
|
||||
hsyscb.Callback[i]();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Добавление периодического коллбека.
|
||||
* @param Callback Указатель на функцию-коллбек
|
||||
* @param PeriodInMs Период вызова коллбека в миллисекундах
|
||||
* @retval OperationStatus OK при успехе, ERROR при ошибке
|
||||
* @note Максимальное количество коллбеков: SYSCLK_NUMB_OF_CUSTOM_CALLBACKS
|
||||
* @note Минимальный период: текущий период тика SysTick
|
||||
*/
|
||||
OperationStatus SYSCLK_Set_Callback(void (*Callback)(void), uint32_t PeriodInMs)
|
||||
{
|
||||
/* Проверка валидности указателя на функцию */
|
||||
if(Callback == NULL)
|
||||
return ERROR;
|
||||
|
||||
/* Проверка минимального периода */
|
||||
if(PeriodInMs < msTickInc)
|
||||
return ERROR;
|
||||
|
||||
/* Проверка доступности свободных слотов */
|
||||
if(hsyscb.CallbackInUse >= SYSCLK_NUMB_OF_CUSTOM_CALLBACKS)
|
||||
return ERROR;
|
||||
|
||||
/* Регистрация коллбека */
|
||||
hsyscb.Callback[hsyscb.CallbackInUse] = Callback;
|
||||
hsyscb.CallbackPeriod[hsyscb.CallbackInUse] = PeriodInMs;
|
||||
hsyscb.CallbackPrevMs[hsyscb.CallbackInUse] = msTick;
|
||||
|
||||
hsyscb.CallbackInUse++;
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Получение текущего времени в миллисекундах.
|
||||
* @retval uint32_t Текущее время в миллисекундах
|
||||
* @note Переполнение происходит через ~49 дней
|
||||
*/
|
||||
uint32_t millis(void)
|
||||
{
|
||||
return msTick;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получение текущего времени в микросекундах.
|
||||
* @retval uint32_t Текущее время в микросекундах
|
||||
* @note Переполнение происходит через ~71 минуту
|
||||
*/
|
||||
uint32_t micros(void)
|
||||
{
|
||||
return usTick;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Настройка тактирования АЦП.
|
||||
* @param ClkSrc Источник тактирования (RCU_PeriphClk_TypeDef)
|
||||
* @param ClkMHz Желаемая частота АЦП в МГц
|
||||
* @param state Состояние (ENABLE/DISABLE)
|
||||
* @retval OperationStatus OK при успехе, ERROR при ошибке
|
||||
* @note Временное отключает тактирование АЦП во время настройки
|
||||
*/
|
||||
OperationStatus rcu_set_clock_adc(RCU_PeriphClk_TypeDef ClkSrc, float ClkMHz, FunctionalState state)
|
||||
{
|
||||
uint32_t adc_raw_clock = 0;
|
||||
float adc_clock_div = 0;
|
||||
|
||||
/* Отключение тактирования АЦП для настройки */
|
||||
RCU_ADCClkCmd(DISABLE);
|
||||
|
||||
/* Определение частоты источника тактирования */
|
||||
switch(ClkSrc)
|
||||
{
|
||||
case RCU_PeriphClk_OSEClk:
|
||||
adc_raw_clock = RCU_GetOSEClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_OSIClk:
|
||||
adc_raw_clock = RCU_GetOSIClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_PLLClk:
|
||||
adc_raw_clock = RCU_GetPLLClkFreq();
|
||||
break;
|
||||
case RCU_PeriphClk_PLLDivClk:
|
||||
adc_raw_clock = RCU_GetPLLDivClkFreq();
|
||||
break;
|
||||
default:
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
/* Расчет делителя частоты */
|
||||
adc_clock_div = adc_raw_clock / (ClkMHz * __MHZ);
|
||||
if(adc_clock_div < 1)
|
||||
return ERROR;
|
||||
|
||||
/* Настройка источника тактирования и делителя */
|
||||
RCU_ADCClkConfig(ClkSrc, (uint32_t)(adc_clock_div - 1), ENABLE);
|
||||
|
||||
/* Включение тактирования, если запрошено */
|
||||
if(state == ENABLE)
|
||||
{
|
||||
RCU_ADCClkCmd(ENABLE);
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Инкремент счетчика миллисекунд.
|
||||
*/
|
||||
static inline void millis_inc(void)
|
||||
{
|
||||
msTick+=msTickInc;
|
||||
}
|
||||
/**
|
||||
* @brief Инкремент счетчика микросекунд.
|
||||
*/
|
||||
static inline void micros_inc(void)
|
||||
{
|
||||
usTick+=usTickInc;
|
||||
}
|
||||
78
MDK-ARM/Core/App/sysclk.h
Normal file
78
MDK-ARM/Core/App/sysclk.h
Normal file
@@ -0,0 +1,78 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file sysclk.h
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер тактирования системы на основе PLIB035.
|
||||
* Данный файл содержит определения типов, структур и прототипы функций
|
||||
* для работы с системным тактированием, включая:
|
||||
* + Типы системных тиков
|
||||
* + Структуру для управления коллбеками
|
||||
* + Прототипы функций для инициализации тактирования
|
||||
* + Функции настройки тактирования периферии
|
||||
* + Функции работы со временем
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __RCU_H
|
||||
#define __RCU_H
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
/** @brief Конвертация МГц в Гц */
|
||||
#define __MHZ 1000000
|
||||
|
||||
/** @brief Максимальное количество коллбеков */
|
||||
#define SYSCLK_NUMB_OF_CUSTOM_CALLBACKS 16
|
||||
|
||||
|
||||
//-- Exported variables --------------------------------------------------------
|
||||
extern __IO uint32_t msTick;
|
||||
extern __IO uint32_t usTick;
|
||||
|
||||
//-- Types ---------------------------------------------------------------------
|
||||
/**
|
||||
* @brief Типы частот системных тиков
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
SYSCLK_Tick_1us = 1000000, /**< Тик 1 микросекунда */
|
||||
SYSCLK_Tick_10us = 100000, /**< Тик 10 микросекунд */
|
||||
SYSCLK_Tick_100us = 10000, /**< Тик 100 микросекунд */
|
||||
SYSCLK_Tick_1ms = 1000, /**< Тик 1 миллисекунда */
|
||||
SYSCLK_Tick_10ms = 100, /**< Тик 10 миллисекунд */
|
||||
SYSCLK_Tick_100ms = 10, /**< Тик 100 миллисекунд */
|
||||
}SYSCLK_TickHz_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура для управления системными коллбеками
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
int CallbackInUse; /**< Количество активных коллбеков */
|
||||
void (*Callback[SYSCLK_NUMB_OF_CUSTOM_CALLBACKS])(void); /**< Массив указателей на функции-коллбеки */
|
||||
uint32_t CallbackPeriod[SYSCLK_NUMB_OF_CUSTOM_CALLBACKS]; /**< Периоды вызова коллбеков в мс */
|
||||
uint32_t CallbackPrevMs[SYSCLK_NUMB_OF_CUSTOM_CALLBACKS]; /**< Время последнего вызова коллбеков */
|
||||
} SYSCLK_CallbackHandleTypeDef;
|
||||
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
/* Инициализация системного тактирования */
|
||||
void sysclk_init(void);
|
||||
/* Общий обработчик прерываний SysClock */
|
||||
void sysclk_irq_handler(void);
|
||||
|
||||
/* Добавление периодического коллбека */
|
||||
OperationStatus SYSCLK_Set_Callback(void (*Callback)(void), uint32_t PeriodInMs);
|
||||
|
||||
/* Получение текущего времени в миллисекундах */
|
||||
uint32_t millis(void);
|
||||
/* Получение текущего времени в микросекундах */
|
||||
uint32_t micros(void);
|
||||
|
||||
/* Настройка тактирования АЦП */
|
||||
OperationStatus rcu_set_clock_adc(RCU_PeriphClk_TypeDef ClkSrc, float ClkMHz, FunctionalState state);
|
||||
#endif /*__RCU_H*/
|
||||
423
MDK-ARM/Core/App/tmr.c
Normal file
423
MDK-ARM/Core/App/tmr.c
Normal file
@@ -0,0 +1,423 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file tmr.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер таймеров на основе PLIB035.
|
||||
* Этот файл содержит:
|
||||
* + Инициализацию таймеров TMR0-TMR3
|
||||
* + Запуск и остановку таймера
|
||||
* + Блокирующие и неблокирующие задержки
|
||||
* + Настройку callback-функций
|
||||
* + Общий обработчик прерываний таймера
|
||||
* + Псевдо-PLIB функции для инициализации таймеров
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Использование этого драйвера предполагает наличие корректных настроек:
|
||||
* - Определены конфигурационные структуры tmrx_config в periph_config.h
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот драйвер #####
|
||||
==============================================================================
|
||||
|
||||
1. Настройка в periph_config.h:
|
||||
(+) Определите структуры tmr0_config, tmr1_config и т.д.
|
||||
(+) Используйте макросы для задания периода:
|
||||
• PERIOD_US(us) - период в микросекундах
|
||||
• FREQ_HZ(hz) - частота в герцах
|
||||
• LOAD(ticks, presc) - период в тиках с псевдопрескалером
|
||||
|
||||
2. Инициализация:
|
||||
(+) tmr_init_first() - включает тактирование и сброс таймеров
|
||||
(+) Для каждого таймера автоматически создается хендл (htmr0, htmr1...)
|
||||
|
||||
3. Работа с таймером:
|
||||
(+) TMR_Start(&htmr, IT) / TMR_Stop(&htmr, IT) - запуск и остановка
|
||||
(+) TMR_Set_Callback(&htmr, TMR_Callback_Update, func) - установка обработчика
|
||||
(+) TMR_Get_Cnt(&htmr) - текущее значение (уже поделенное на прескалер)
|
||||
(+) TMR_Get_Period(&htmr) - период (уже поделенный на прескалер)
|
||||
|
||||
4. Задержки:
|
||||
(+) TMR_Delay(&htmr, ticks) - блокирующая задержка в тиках таймера с псевдопрескалером
|
||||
(+) TMR_Delay_Start(&htmr, &var) + TMR_Delay_Done(&htmr, ticks, &var) - неблокирующая
|
||||
задержка в тиках таймера с псевдопрескалером
|
||||
|
||||
5. Обработка прерываний:
|
||||
(+) Callback-функция будет вызвана автоматически
|
||||
|
||||
==============================================================================
|
||||
##### Особенности работы #####
|
||||
==============================================================================
|
||||
|
||||
- Псевдопрескалер:
|
||||
- Это программная абстракция, реальный счетчик всегда считает полные тики
|
||||
- TMR_Get_Cnt() возвращает значение уже поделенное на (Prescaler+1)
|
||||
- Позволяет увеличить максимальный период в (Prescaler+1) раз
|
||||
- Пример: LOAD(1000, 99) даст реальный период в 100 раз больше
|
||||
|
||||
- Особенности счетчиков:
|
||||
- Максимальный период: 42.9 сек при 100 МГц
|
||||
- Таймеры используют убывающий счет (от LOAD до 0). Функция TMR_Get_Cnt
|
||||
возвращает инвертированный счетчик (LOAD-VALUE)
|
||||
|
||||
- Задержки:
|
||||
- TMR_Delay проверяет, что задержка < LOAD, иначе вернет ERROR
|
||||
- Неблокирующие задержки используют "сырые" тики (без учета прескалера)
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "periph_config.h"
|
||||
|
||||
TMR_HandleTypeDef htmr0; /*!< Хендл TMR0 */
|
||||
TMR_HandleTypeDef htmr1; /*!< Хендл TMR1 */
|
||||
TMR_HandleTypeDef htmr2; /*!< Хендл TMR2 */
|
||||
TMR_HandleTypeDef htmr3; /*!< Хендл TMR3 */
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
//-- TMR Init functions --------------------------------------------------------
|
||||
/**
|
||||
* @brief Первичная инициализация таймеров TMR0-TMR3
|
||||
* @details Настройка таймеров и хендлов: тактирование, прерывания
|
||||
*/
|
||||
void tmr_init_first(void)
|
||||
{
|
||||
#if (USE_TMR0==1)
|
||||
RCU_APBClkCmd(RCU_APBClk_TMR0, ENABLE);
|
||||
RCU_APBRstCmd(RCU_APBRst_TMR0, ENABLE);
|
||||
|
||||
htmr0.Instance = TMR0;
|
||||
tmr_init(&htmr0, &tmr0_config);
|
||||
if(htmr0.Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(TMR0_IRQn);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (USE_TMR1==1)
|
||||
RCU_APBClkCmd(RCU_APBClk_TMR1, ENABLE);
|
||||
RCU_APBRstCmd(RCU_APBRst_TMR1, ENABLE);
|
||||
|
||||
htmr1.Instance = TMR1;
|
||||
tmr_init(&htmr1, &tmr1_config);
|
||||
if(htmr1.Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(TMR1_IRQn);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (USE_TMR2==1)
|
||||
RCU_APBClkCmd(RCU_APBClk_TMR2, ENABLE);
|
||||
RCU_APBRstCmd(RCU_APBRst_TMR2, ENABLE);
|
||||
|
||||
htmr2.Instance = TMR2;
|
||||
tmr_init(&htmr2, &tmr2_config);
|
||||
if(htmr2.Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(TMR2_IRQn);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (USE_TMR3==1)
|
||||
RCU_APBClkCmd(RCU_APBClk_TMR3, ENABLE);
|
||||
RCU_APBRstCmd(RCU_APBRst_TMR3, ENABLE);
|
||||
|
||||
htmr3.Instance = TMR3;
|
||||
tmr_init(&htmr3, &tmr3_config);
|
||||
if(htmr3.Config->IT == ENABLE)
|
||||
{
|
||||
NVIC_EnableIRQ(TMR3_IRQn);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Инициализация таймера
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @param NewConfig указатель на новую конфигурацию UART, иначе используется та, что в структуре
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_ExtInit_TypeDef *NewConfig)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
return ERROR;
|
||||
|
||||
if(NewConfig != NULL)
|
||||
{
|
||||
htmr->Config = NewConfig;
|
||||
}
|
||||
if(htmr->Config == NULL)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
TMR_Init(htmr->Instance, htmr->Config);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Установка коллбека таймера
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @param CallbackType Тип коллбека
|
||||
* @param UpdCallback Функция коллбека
|
||||
* @retval void
|
||||
*/
|
||||
OperationStatus TMR_Set_Callback(TMR_HandleTypeDef* htmr, TMR_CallbackTypeDef CallbackType, void (*Callback)(void))
|
||||
{
|
||||
if(!htmr || !htmr->Instance || !htmr->Config)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
|
||||
switch(CallbackType)
|
||||
{
|
||||
case TMR_Callback_Update:
|
||||
htmr->Config->UpdCallback = Callback;
|
||||
break;
|
||||
default:
|
||||
return ERROR;
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
||||
//-- TMR API functions --------------------------------------------------------
|
||||
/**
|
||||
* @brief Запуск таймера
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus TMR_Start(TMR_HandleTypeDef *htmr, FunctionalState IT)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
TMR_ITCmd(htmr->Instance, IT);
|
||||
TMR_Cmd(htmr->Instance, ENABLE);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Остановка таймера
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus TMR_Stop(TMR_HandleTypeDef *htmr, FunctionalState IT)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
TMR_ITCmd(htmr->Instance, IT);
|
||||
TMR_Cmd(htmr->Instance, DISABLE);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получить счетчик таймера (с псевдопрескалером)
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @retval Текущие значение счетчика с псевдопрескалером
|
||||
* @details Если частота таймера 100 МГц, и псведопрескалер 100-1,
|
||||
* то при реальном счетчике 100,000, вернется значение 1,000
|
||||
* Также переводит счетчик в возрастающий (LOAD-VALUE)
|
||||
*/
|
||||
uint32_t TMR_Get_Cnt(TMR_HandleTypeDef *htmr)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
uint32_t presc = htmr->Config->Prescaler+1;
|
||||
uint32_t currtick = (htmr->Instance->LOAD - htmr->Instance->VALUE);
|
||||
|
||||
return currtick/presc;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Получить период таймера (с псевдопрескалером)
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @retval Период с псевдопрескалером
|
||||
* @details Если частота таймера 100 МГц, и псведопрескалер 100-1, и период равен 1 мс,
|
||||
* то при реальном периоде 100,000, вернется значение 1,000
|
||||
*/
|
||||
uint32_t TMR_Get_Period(TMR_HandleTypeDef *htmr)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
uint32_t presc = htmr->Config->Prescaler+1;
|
||||
uint32_t currload = htmr->Instance->LOAD;
|
||||
|
||||
return currload/presc;
|
||||
}
|
||||
//-- TMR Delays API functions -------------------------------------------------
|
||||
/**
|
||||
* @brief Задержка в тиках таймера (блокирующая).
|
||||
* @param htmr Указатель на хендл таймера.
|
||||
* @param delay Задержка в тиках таймера.
|
||||
* @return OperationStatus.
|
||||
* @details Формирует задержку с блокировкой программы.
|
||||
*/
|
||||
OperationStatus TMR_Delay(TMR_HandleTypeDef *htmr, uint32_t delay)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
return ERROR;
|
||||
|
||||
uint32_t presc = htmr->Config->Prescaler+1;
|
||||
uint64_t delay_load = delay*presc;
|
||||
if(delay_load > 0xFFFFFFFF)
|
||||
{
|
||||
delay_load = 0xFFFFFFFF;
|
||||
}
|
||||
|
||||
if(delay_load >= htmr->Instance->LOAD)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
uint32_t starttick = htmr->Instance->VALUE;
|
||||
while(1)
|
||||
{
|
||||
if((starttick - htmr->Instance->VALUE) >= delay_load)
|
||||
{
|
||||
return OK;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Начать отсчет неблокирующей задержки.
|
||||
* @param htmr Указатель на хендл таймера.
|
||||
* @param var Указатель на переменную куда положить значение тиков.
|
||||
* @return OperationStatus.
|
||||
* @details Запоминает счетчик для начала отсчета неблокирующей задержки.
|
||||
* @ref TMR_Delay_Done для проверки статуса задержки.
|
||||
* @note Переменная содержит сырые тики, без преобразования под псевдопрескалер,
|
||||
* поэтому в var могут быть неадекватно большие значения тиков
|
||||
*/
|
||||
OperationStatus TMR_Delay_Start(TMR_HandleTypeDef *htmr, uint32_t *var)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
return ERROR;
|
||||
|
||||
*var = htmr->Instance->VALUE;
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Задержка в тиках таймера (неблокирующая).
|
||||
* @param htmr Указатель на хендл таймера.
|
||||
* @param delay Задержка в тиках таймера.
|
||||
* @param var Указатель на переменную где хранится тики в момент начала задержки.
|
||||
* @return 1 - задержка прошла. 0 - задержка в процессе.
|
||||
* @details Формирует задержку с блокировкой программы.
|
||||
* Перед ожиданием задержки надо инициализировать задержку @ref TMR_Delay_Start
|
||||
* @note Функция считает задержку через сырые тики, поэтому в var могут быть
|
||||
* неадекватно большие значения тиков
|
||||
*/
|
||||
int TMR_Delay_Done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var)
|
||||
{
|
||||
if(!htmr || !htmr->Instance)
|
||||
return 0;
|
||||
|
||||
uint32_t presc = htmr->Config->Prescaler+1;
|
||||
uint64_t delay_load = delay*presc;
|
||||
if(delay_load > 0xFFFFFFFF)
|
||||
{
|
||||
delay_load = 0xFFFFFFFF;
|
||||
}
|
||||
|
||||
if(delay_load >= htmr->Instance->LOAD)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
if((*var - htmr->Instance->VALUE) >= delay_load)
|
||||
{
|
||||
return 1; // Задержка прошла
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-- TMR Handler functions ----------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Обработчик прерывания таймера
|
||||
* @param htmr указатель на хендл таймера
|
||||
* @retval void
|
||||
*/
|
||||
void tmr_irq_handler(TMR_HandleTypeDef* htmr)
|
||||
{
|
||||
if((htmr->Instance == NULL) || (htmr->Config == NULL))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
/* Проверка флага прерывания таймера */
|
||||
if (TMR_ITStatus(htmr->Instance) == SET)
|
||||
{
|
||||
/* Если есть коллбек вызываем его */
|
||||
if(htmr->Config->UpdCallback)
|
||||
htmr->Config->UpdCallback();
|
||||
|
||||
/* Очистка флага прерывания */
|
||||
TMR_ITStatusClear(htmr->Instance);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//-- TMR pseudoPLIB functions -------------------------------------------------
|
||||
/**
|
||||
* @brief Инициализирует модуль TMRx согласно параметрам структуры InitStruct.
|
||||
* @param TMRx Выбор таймера, где x=A|B
|
||||
* @param InitStruct Указатель на структуру типа @ref TMR_ExtInit_TypeDef,
|
||||
* которая содержит конфигурационную информацию
|
||||
* @retval void
|
||||
*/
|
||||
void TMR_Init(TMR_TypeDef* TMRx, TMR_ExtInit_TypeDef* InitStruct)
|
||||
{
|
||||
uint32_t tim_clk = InitStruct->ClkFreq*__MHZ;
|
||||
uint32_t presc = InitStruct->Prescaler+1;
|
||||
if(InitStruct->PeriodUs)
|
||||
{
|
||||
TMR_PeriodConfig(TMRx, tim_clk, InitStruct->PeriodUs);
|
||||
}
|
||||
else if(InitStruct->FreqHz)
|
||||
{
|
||||
TMR_FreqConfig(TMRx, tim_clk, InitStruct->FreqHz);
|
||||
}
|
||||
else
|
||||
{
|
||||
uint64_t load = (uint64_t)InitStruct->Load*presc;
|
||||
if(load > 0xFFFFFFFF)
|
||||
load = 0xFFFFFFFF;
|
||||
TMR_SetLoad(TMRx, load);
|
||||
}
|
||||
|
||||
TMR_ITCmd(TMRx, InitStruct->IT);
|
||||
|
||||
TMR_DMAReqCmd(TMRx, InitStruct->DMAReq);
|
||||
TMR_ADCSOCCmd(TMRx, InitStruct->ADCSOC);
|
||||
TMR_ExtInputConfig(TMRx, InitStruct->ExtInput);
|
||||
}
|
||||
|
||||
111
MDK-ARM/Core/App/tmr.h
Normal file
111
MDK-ARM/Core/App/tmr.h
Normal file
@@ -0,0 +1,111 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file tmr.h
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер UART на основе PLIB035.
|
||||
* Данный файл содержит определения типов, структур и прототипы функций
|
||||
* для работы с TMR, включая:
|
||||
* + Структуры и typedef для таймеров
|
||||
* + Макросы для конфигурации периодов и частот
|
||||
* + Прототипы функций для инициализации и API драйвера
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
#ifndef __TMR_H
|
||||
#define __TMR_H
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
// Дефайны для режима таймера Период в мкс, Частота, ПсевдоПрескалер, Период в тиках
|
||||
/** @brief Период в мкс */
|
||||
#define PERIOD_US(_per_) (_per_), 0, 0, 0
|
||||
/** @brief Период в Гц */
|
||||
#define FREQ_HZ(_freq_) 0, (_freq_), 0, 0
|
||||
/** @brief Период в прескалере и тиках */
|
||||
#define LOAD(_load_, _presc_) 0, 0, (_presc_), (_load_)
|
||||
|
||||
//-- Types ---------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Типы callback-функций TMR
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
TMR_Callback_Update, /*!< Переполнение (опустошение) таймера */
|
||||
} TMR_CallbackTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Расширенная конфигурация таймера
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
float ClkFreq; /*!< Частота тактирования таймера в МГц */
|
||||
|
||||
uint32_t PeriodUs; /*!< Период таймера в мкс */
|
||||
uint32_t FreqHz; /*!< Частота таймера в Гц */
|
||||
uint32_t Prescaler; /*!< Псевдопрескалер */
|
||||
uint32_t Load; /*!< Период таймера в тиках */
|
||||
|
||||
FunctionalState IT; /*!< Разрешение прерывания */
|
||||
FunctionalState ADCSOC; /*!< Разрешение генерации запуска АЦП */
|
||||
FunctionalState DMAReq; /*!< Разрешение генерации DMA-запросов */
|
||||
TMR_ExtInput_TypeDef ExtInput; /*!< Настройка внешнего тактирования таймера */
|
||||
|
||||
void (*UpdCallback)(void); /*!< Callback-функция по прерыванию таймера */
|
||||
} TMR_ExtInit_TypeDef;
|
||||
|
||||
/**
|
||||
* @brief Хендл таймера
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
TMR_TypeDef *Instance; /*!< Указатель на регистры таймера */
|
||||
TMR_ExtInit_TypeDef *Config; /*!< Конфигурация таймера */
|
||||
} TMR_HandleTypeDef;
|
||||
|
||||
//-- External handles ----------------------------------------------------------
|
||||
extern TMR_HandleTypeDef htmr0;
|
||||
extern TMR_HandleTypeDef htmr1;
|
||||
extern TMR_HandleTypeDef htmr2;
|
||||
extern TMR_HandleTypeDef htmr3;
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
|
||||
/* Init functions */
|
||||
|
||||
/* Первичная инициализация таймеров */
|
||||
void tmr_init_first(void);
|
||||
/* Общий обработчик прерывания таймера */
|
||||
void tmr_irq_handler(TMR_HandleTypeDef* htmr);
|
||||
/* Инициализация TMRx */
|
||||
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_ExtInit_TypeDef *NewConfig);
|
||||
/* Инициализация таймера (её нет в PLIB, поэтому она здесь) */
|
||||
void TMR_Init(TMR_TypeDef* TMRx, TMR_ExtInit_TypeDef* InitStruct);
|
||||
|
||||
/* Установка callback-функции таймера */
|
||||
OperationStatus TMR_Set_Callback(TMR_HandleTypeDef* htmr, TMR_CallbackTypeDef CallbackType, void (*Callback)(void));
|
||||
|
||||
|
||||
|
||||
/* API functions*/
|
||||
|
||||
/* Запуск таймера */
|
||||
OperationStatus TMR_Start(TMR_HandleTypeDef *htmr, FunctionalState IT);
|
||||
/* Остановка таймера */
|
||||
OperationStatus TMR_Stop(TMR_HandleTypeDef *htmr, FunctionalState IT);
|
||||
/*Получить счетчик таймера (с псевдопрескалером) */
|
||||
uint32_t TMR_Get_Cnt(TMR_HandleTypeDef *htmr);
|
||||
/* Получить период таймера (с псевдопрескалером) */
|
||||
uint32_t TMR_Get_Period(TMR_HandleTypeDef *htmr);
|
||||
|
||||
/* Задержка в тиках таймера (блокирующая). */
|
||||
OperationStatus TMR_Delay(TMR_HandleTypeDef *htmr, uint32_t delay);
|
||||
/* Проверка завершения неблокирующей задержки. */
|
||||
OperationStatus TMR_Delay_Start(TMR_HandleTypeDef *htmr, uint32_t *var);
|
||||
/* Проверка завершения неблокирующей задержки. */
|
||||
int TMR_Delay_Done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var);
|
||||
|
||||
|
||||
#endif /*__TMR_H*/
|
||||
776
MDK-ARM/Core/App/uart.c
Normal file
776
MDK-ARM/Core/App/uart.c
Normal file
@@ -0,0 +1,776 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file uart.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер UART на основе PLIB035.
|
||||
* Этот файл содержит:
|
||||
* + Инициализацию UART0/UART1
|
||||
* + Управление FIFO
|
||||
* + Передачу и приём данных в blocking и interrupt режимах
|
||||
* + Общий обработчик прерываний UART
|
||||
* + Функции настройки GPIO для UART
|
||||
* + Очередь передачи для предотвращения потери данных
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Использование этого драйвера предполагает наличие корректных настроек:
|
||||
* - Определены конфигурационные структуры uartx_config в periph_config.h
|
||||
* - Определены пины TX/RX для UART0/UART1
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот драйвер #####
|
||||
==============================================================================
|
||||
|
||||
1. Настройка в periph_config.h:
|
||||
(+) Определите uart0_config, uart1_config для нужных UART
|
||||
(+) Используйте макросы для направления:
|
||||
• UART_Direction_None - прием и передача отключены
|
||||
• UART_Direction_RxTx - полный дуплекс
|
||||
• UART_Direction_Tx - только передача
|
||||
• UART_Direction_Rx - только прием
|
||||
|
||||
2. Инициализация:
|
||||
(+) uart_init_first() - настройка GPIO, тактирования и прерываний
|
||||
(+) uart_init(&huart, &config) - инициализация конкретного UART
|
||||
|
||||
3. Callback-функции:
|
||||
(+) UART_Set_Callback(&huart, UART_Callback_Rx, func) - при завершении приема
|
||||
(+) UART_Set_Callback(&huart, UART_Callback_Tx, func) - при завершении передачи
|
||||
(+) UART_Set_Callback(&huart, UART_Callback_Idle, func) - при обнаружении IDLE
|
||||
(+) UART_Set_Callback(&huart, UART_Callback_Error, func) - при ошибках
|
||||
|
||||
4. Запуск UART:
|
||||
(+) UART_Start(&huart, TxFifoLevel, RxFifoLevel) - включение UART и настройка FIFO
|
||||
|
||||
5. Передача и приём данных:
|
||||
- Режим Polling:
|
||||
(+) UART_Transmit(&huart, buf, size, timeout) - блокирующая передача
|
||||
(+) UART_Receive(&huart, buf, size, timeout) - блокирующий прием
|
||||
- Режим Interrupt:
|
||||
(+) UART_Transmit_IT(&huart, buf, size) - неблокирующая передача
|
||||
(+) UART_Receive_IT(&huart, buf, size) - неблокирующий прием
|
||||
|
||||
6. Обработка прерываний:
|
||||
(+) Прерывания обрабатывают TX FIFO, RX FIFO, ошибки и состояние IDLE
|
||||
|
||||
7. GPIO для UART:
|
||||
(+) Пины настраиваются автоматически при вызове uart_init_first()
|
||||
(+) При необходимости можно вызвать uart0_gpio_deinit() для восстановления
|
||||
|
||||
==============================================================================
|
||||
##### Особенности работы #####
|
||||
==============================================================================
|
||||
|
||||
- Очередь передачи (USE_TX_QUEUE):
|
||||
- Циклический буфер на 32 сообщения (TX_QUEUE_SIZE)
|
||||
- Предотвращает потерю данных при частой отправке
|
||||
- Включается автоматически при USE_TX_QUEUE=1 в uart.h
|
||||
- Сообщения обрабатываются последовательно по завершении предыдущей передачи
|
||||
|
||||
- FIFO и прерывания:
|
||||
- Аппаратный FIFO 16 байт для приема и передачи
|
||||
- Уровни прерываний настраиваются через TxFifoLevel и RxFifoLevel
|
||||
- Прерывание TX FIFO генерируется когда FIFO не полон
|
||||
- Прерывание RX FIFO генерируется когда FIFO не пуст
|
||||
|
||||
- Состояние IDLE:
|
||||
- Обнаруживается по таймауту приема (32 бит-времени)
|
||||
- Генерирует прерывание RecieveTimeout
|
||||
- Полезно для определения конца пакета переменной длины
|
||||
|
||||
- Обработка ошибок:
|
||||
- Обрабатываются все типы ошибок UART: фрейм, паритет, переполнение, break
|
||||
- При ошибке вызывается ErrCallback и сбрасываются флаги ошибок
|
||||
- Ошибки не останавливают работу UART
|
||||
|
||||
- GPIO автоматическая настройка:
|
||||
- Пины TX/RX настраиваются в AltFunc режим при инициализации
|
||||
- Поддерживаются стандартные пины (PB10/PB11 для UART0, PB8/PB9 для UART1)
|
||||
|
||||
- Режимы работы:
|
||||
- Polling: простой, но блокирующий, подходит для инициализации и отладки
|
||||
- Interrupt: неблокирующий, требует прерываний и поддерживает callback-функций
|
||||
- Queue: расширенный interrupt режим с буферизацией сообщений
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "periph_config.h"
|
||||
|
||||
UART_HandleTypeDef huart0; /*!< Хендл UART0 */
|
||||
UART_HandleTypeDef huart1; /*!< Хендл UART1 */
|
||||
|
||||
|
||||
//-- Private function prototypes -----------------------------------------------
|
||||
static int __uart_fifo_receive(UART_HandleTypeDef *huart, uint8_t it_mode);
|
||||
static int __uart_fifo_transmit(UART_HandleTypeDef *huart, uint8_t it_mode);
|
||||
#if USE_TX_QUEUE==1
|
||||
static void __uart_tx_queue_process(UART_HandleTypeDef *huart);
|
||||
static OperationStatus __uart_tx_queue_push(UART_HandleTypeDef *huart, const uint8_t *buf, uint16_t size);
|
||||
static OperationStatus __uart_tx_queue_pop(UART_HandleTypeDef *huart);
|
||||
#endif
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
//-- UART Init functions -------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Первичная инициализация UART (UART0 / UART1)
|
||||
* @details Настройка UART и хендлов: GPIO, тактирование и прерывания
|
||||
*/
|
||||
void uart_init_first(void)
|
||||
{
|
||||
|
||||
#if (USE_UART0==1)
|
||||
// Настройка пинов для UART0
|
||||
uart0_gpio_init();
|
||||
|
||||
// Включаем тактирование UART0
|
||||
RCU_UARTClkConfig(UART0_Num, RCU_PeriphClk_PLLClk, 0, DISABLE);
|
||||
RCU_UARTClkCmd(UART0_Num, ENABLE);
|
||||
UART_DeInit(UART0);
|
||||
// Инициализируем UART0
|
||||
huart0.Instance = UART0;
|
||||
uart_init(&huart0, &uart0_config);
|
||||
NVIC_EnableIRQ(UART0_TD_IRQn);
|
||||
NVIC_EnableIRQ(UART0_RX_IRQn);
|
||||
NVIC_EnableIRQ(UART0_TX_IRQn);
|
||||
NVIC_EnableIRQ(UART0_E_RT_IRQn);
|
||||
#endif
|
||||
|
||||
|
||||
#if (USE_UART1==1)
|
||||
// Настройка пинов для UART1
|
||||
uart1_gpio_init();
|
||||
|
||||
// Включаем тактирование UART1
|
||||
RCU_UARTClkConfig(UART1_Num, RCU_PeriphClk_PLLClk, 0, DISABLE);
|
||||
RCU_UARTClkCmd(UART1_Num, ENABLE);
|
||||
UART_DeInit(UART1);
|
||||
|
||||
// Инициализируем UART1
|
||||
NVIC_EnableIRQ(UART1_TD_IRQn);
|
||||
NVIC_EnableIRQ(UART1_RX_IRQn);
|
||||
NVIC_EnableIRQ(UART1_TX_IRQn);
|
||||
NVIC_EnableIRQ(UART1_E_RT_IRQn);
|
||||
|
||||
huart1.Instance = UART1;
|
||||
uart_init(&huart1, &uart1_config);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Инициализация UART
|
||||
* @param htmr указатель на хендл UART
|
||||
* @param NewConfig указатель на новую конфигурацию UART, иначе используется та, что в структуре
|
||||
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
|
||||
*/
|
||||
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInit_TypeDef *NewConfig)
|
||||
{
|
||||
if(!huart || !huart->Instance)
|
||||
return ERROR;
|
||||
|
||||
if(NewConfig != NULL)
|
||||
{
|
||||
huart->Config = NewConfig;
|
||||
}
|
||||
if(huart->Config == NULL)
|
||||
{
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
UART_Init(huart->Instance, &huart->Config->UART_Init);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Установка коллбека UART
|
||||
* @param htmr указатель на хендл UART
|
||||
* @param CallbackType Тип коллбека
|
||||
* @param Callback Функция коллбека
|
||||
* @retval void
|
||||
*/
|
||||
OperationStatus UART_Set_Callback(UART_HandleTypeDef* huart, UART_CallbackTypeDef CallbackType, void (*Callback)(void))
|
||||
{
|
||||
if (!huart || !huart->Instance || !huart->Config)
|
||||
return ERROR;
|
||||
|
||||
switch(CallbackType)
|
||||
{
|
||||
case UART_Callback_Rx:
|
||||
huart->Config->RxCallback = Callback;
|
||||
break;
|
||||
case UART_Callback_Tx:
|
||||
huart->Config->TxCallback = Callback;
|
||||
break;
|
||||
case UART_Callback_Idle:
|
||||
huart->Config->IdleCallback = Callback;
|
||||
break;
|
||||
case UART_Callback_Error:
|
||||
huart->Config->ErrCallback = Callback;
|
||||
break;
|
||||
|
||||
default:
|
||||
return ERROR;
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
||||
|
||||
//-- UART API functions --------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Запуск UART и инициализация FIFO
|
||||
* @param huart указатель на хендл UART
|
||||
* @param TxFifoLevel уровень прерывания TX FIFO
|
||||
* @param RxFifoLevel уровень прерывания RX FIFO
|
||||
* @retval OperationStatus OK - если успешно, ERROR - при ошибке
|
||||
*/
|
||||
OperationStatus UART_Start(UART_HandleTypeDef *huart, UART_FIFOLevel_TypeDef TxFifoLevel, UART_FIFOLevel_TypeDef RxFifoLevel)
|
||||
{
|
||||
if (!huart)
|
||||
return ERROR;
|
||||
|
||||
UART_ITFIFOLevelRxConfig(huart->Instance, RxFifoLevel);
|
||||
UART_ITFIFOLevelTxConfig(huart->Instance, TxFifoLevel);
|
||||
|
||||
|
||||
huart->TxBufPtr = NULL;
|
||||
huart->TxCount = 0;
|
||||
huart->TxSize = 0;
|
||||
huart->TxBusy = 0;
|
||||
|
||||
huart->RxBufPtr = NULL;
|
||||
huart->RxCount = 0;
|
||||
huart->RxSize = 0;
|
||||
huart->RxBusy = 0;
|
||||
|
||||
#if USE_TX_QUEUE==1
|
||||
huart->TxQueue.QueueHead = 0;
|
||||
huart->TxQueue.QueueTail = 0;
|
||||
huart->TxQueue.QueueCount = 0;
|
||||
huart->TxQueue.QueueEmpty = 1;
|
||||
huart->TxQueue.QueueFull = 0;
|
||||
|
||||
for (uint8_t i = 0; i < TX_QUEUE_SIZE; i++)
|
||||
{
|
||||
huart->TxQueue.Queue[i].Buf = NULL;
|
||||
huart->TxQueue.Queue[i].Size = 0;
|
||||
huart->TxQueue.Queue[i].InUse = 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
UART_Cmd(huart->Instance, ENABLE);
|
||||
|
||||
return OK;
|
||||
}
|
||||
/**
|
||||
* @brief Передача данных по UART (блокирующий режим)
|
||||
* @param huart указатель на хендл UART
|
||||
* @param buf указатель на буфер данных
|
||||
* @param size размер данных в байтах
|
||||
* @param timeout таймаут ожидания (мс)
|
||||
* @retval OperationStatus OK - если успешно, ERROR - при ошибке или таймауте
|
||||
*/
|
||||
OperationStatus UART_Transmit(UART_HandleTypeDef *huart,
|
||||
uint8_t *buf,
|
||||
uint16_t size,
|
||||
uint32_t timeout)
|
||||
{
|
||||
if (!huart || !buf || size == 0)
|
||||
return ERROR;
|
||||
|
||||
// Если TX занят, возвращаем ERROR
|
||||
if (huart->TxBusy)
|
||||
return ERROR;
|
||||
|
||||
huart->TxBufPtr = buf;
|
||||
huart->TxSize = size;
|
||||
huart->TxCount = 0;
|
||||
huart->TxBusy = 1;
|
||||
|
||||
uint32_t starttick = millis();
|
||||
// Отправляем пока всё не отправится
|
||||
while(__uart_fifo_transmit(huart, 0) == 0)
|
||||
{
|
||||
if(millis() - starttick > timeout)
|
||||
return ERROR;
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
/**
|
||||
* @brief Приём данных по UART (блокирующий режим)
|
||||
* @param huart указатель на хендл UART
|
||||
* @param buf указатель на буфер приёма
|
||||
* @param size количество принимаемых байт
|
||||
* @param timeout таймаут ожидания (мс)
|
||||
* @retval OperationStatus OK - если успешно, ERROR - при ошибке или таймауте
|
||||
*/
|
||||
OperationStatus UART_Receive(UART_HandleTypeDef *huart,
|
||||
uint8_t *buf,
|
||||
uint16_t size,
|
||||
uint32_t timeout)
|
||||
{
|
||||
if (!huart || !buf || size == 0)
|
||||
return ERROR;
|
||||
|
||||
// Если RX занят, возвращаем ERROR
|
||||
if (huart->RxBusy)
|
||||
return ERROR;
|
||||
|
||||
huart->RxBufPtr = buf;
|
||||
huart->RxSize = size;
|
||||
huart->RxCount = 0;
|
||||
huart->RxBusy = 1;
|
||||
|
||||
uint32_t starttick = millis();
|
||||
// Принимаем всё пока всё не примется
|
||||
while(__uart_fifo_transmit(huart, 0) == 0)
|
||||
{
|
||||
if(millis() - starttick > timeout)
|
||||
return ERROR;;
|
||||
}
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Передача данных по UART (прерывания)
|
||||
* @param huart указатель на хендл UART
|
||||
* @param buf указатель на буфер данных
|
||||
* @param size размер данных в байтах
|
||||
* @retval OperationStatus OK - если успешно, ERROR - если передача уже идёт
|
||||
*/
|
||||
OperationStatus UART_Transmit_IT(UART_HandleTypeDef *huart,
|
||||
uint8_t *buf,
|
||||
uint16_t size)
|
||||
{
|
||||
if (!huart || !buf || size == 0)
|
||||
return ERROR;
|
||||
|
||||
#if USE_TX_QUEUE==1
|
||||
// Автоматически используем очередь
|
||||
if (huart->TxQueue.QueueFull)
|
||||
return ERROR;
|
||||
|
||||
OperationStatus status = __uart_tx_queue_push(huart, buf, size);
|
||||
if (status != OK)
|
||||
return ERROR;
|
||||
|
||||
if (!huart->TxBusy)
|
||||
{
|
||||
__uart_tx_queue_process(huart);
|
||||
}
|
||||
|
||||
return OK;
|
||||
#else
|
||||
// Без очереди
|
||||
// Если TX занят, возвращаем ERROR
|
||||
if (huart->TxBusy)
|
||||
return ERROR;
|
||||
|
||||
huart->TxBufPtr = buf;
|
||||
huart->TxSize = size;
|
||||
huart->TxCount = 0;
|
||||
huart->TxBusy = 1;
|
||||
|
||||
// Включаем прерывания по TX FIFO
|
||||
UART_ITCmd(huart->Instance, UART_ITSource_TxFIFOLevel, ENABLE);
|
||||
|
||||
__uart_fifo_transmit(huart, 1);
|
||||
|
||||
return OK;
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Приём данных по UART (прерывания)
|
||||
* @param huart указатель на хендл UART
|
||||
* @param buf указатель на буфер приёма
|
||||
* @param size количество принимаемых байт
|
||||
* @retval OperationStatus OK - если успешно, ERROR - если приём уже идёт
|
||||
*/
|
||||
OperationStatus UART_Receive_IT(UART_HandleTypeDef *huart,
|
||||
uint8_t *buf,
|
||||
uint16_t size)
|
||||
{
|
||||
if (!huart || !buf || size == 0)
|
||||
return ERROR;
|
||||
|
||||
// Если RX занят, возвращаем ERROR
|
||||
if (huart->RxBusy)
|
||||
return ERROR;
|
||||
|
||||
huart->RxBufPtr = buf;
|
||||
huart->RxSize = size;
|
||||
huart->RxCount = 0;
|
||||
huart->RxBusy = 1;
|
||||
|
||||
// Включаем только RX прерывания
|
||||
UART_ITCmd(huart->Instance,
|
||||
UART_ITSource_RxFIFOLevel |
|
||||
UART_ITSource_RecieveTimeout |
|
||||
UART_ITSource_ErrorFrame |
|
||||
UART_ITSource_ErrorParity |
|
||||
UART_ITSource_ErrorOverflow |
|
||||
UART_ITSource_ErrorBreak,
|
||||
ENABLE);
|
||||
|
||||
return OK;
|
||||
}
|
||||
|
||||
//-- UART Handler functions ---------------------------------------------------
|
||||
/**
|
||||
* @brief Общий обработчик прерываний UART
|
||||
* @param huart указатель на хендл UART
|
||||
* @details Обрабатывает RX/TX FIFO, ошибки и события Idle
|
||||
* @retval void
|
||||
*/
|
||||
void uart_irq_handler(UART_HandleTypeDef *huart)
|
||||
{
|
||||
if (!huart || !huart->Instance || !huart->Config)
|
||||
return;
|
||||
|
||||
// GPIO_SetBits(GPIOA, GPIO_Pin_7);
|
||||
|
||||
UART_TypeDef *uart = huart->Instance;
|
||||
uint32_t mis = uart->MIS;
|
||||
|
||||
// Ошибки
|
||||
if (mis & (UART_ITSource_ErrorFrame |
|
||||
UART_ITSource_ErrorParity |
|
||||
UART_ITSource_ErrorOverflow |
|
||||
UART_ITSource_ErrorBreak))
|
||||
{
|
||||
if (huart->Config->ErrCallback)
|
||||
huart->Config->ErrCallback();
|
||||
|
||||
UART_ErrorStatusClear(uart, UART_Error_All);
|
||||
UART_ITStatusClear(uart, mis);
|
||||
}
|
||||
|
||||
// RX FIFO
|
||||
if (mis & UART_ITSource_RxFIFOLevel)
|
||||
{
|
||||
// Принимаем
|
||||
if(__uart_fifo_receive(huart, 1))
|
||||
{ // Когда всё приняли, флаги сбросили внутри функции
|
||||
}
|
||||
|
||||
UART_ITStatusClear(uart, UART_ITSource_RxFIFOLevel);
|
||||
}
|
||||
|
||||
// IDLE / Receive Timeout
|
||||
if (mis & UART_ITSource_RecieveTimeout)
|
||||
{
|
||||
UART_ITStatusClear(uart, UART_ITSource_RecieveTimeout);
|
||||
|
||||
huart->RxBusy = 0;
|
||||
// Выключаем RX прерывания до следующего вызова UART_Receive_IT
|
||||
UART_ITCmd(uart,
|
||||
UART_ITSource_RxFIFOLevel |
|
||||
UART_ITSource_RecieveTimeout,
|
||||
DISABLE);
|
||||
|
||||
if (huart->Config->IdleCallback)
|
||||
huart->Config->IdleCallback();
|
||||
}
|
||||
|
||||
// TX FIFO
|
||||
if (mis & UART_ITSource_TxFIFOLevel)
|
||||
{
|
||||
// Отправляем
|
||||
if(__uart_fifo_transmit(huart, 1))
|
||||
{ // Когда всё отправили, флаги сбросили внутри функции
|
||||
}
|
||||
|
||||
UART_ITStatusClear(uart, UART_ITSource_TxFIFOLevel);
|
||||
}
|
||||
|
||||
// Конец передачи
|
||||
if (mis & UART_ITSource_TransmitDone)
|
||||
{
|
||||
UART_ITStatusClear(uart, UART_ITSource_TransmitDone);
|
||||
huart->TxBusy = 0;
|
||||
|
||||
if (huart->Config->TxCallback)
|
||||
huart->Config->TxCallback();
|
||||
|
||||
#if USE_TX_QUEUE==1
|
||||
// Если есть очередь, обрабатываем следующий пакет
|
||||
__uart_tx_queue_process(huart);
|
||||
#endif
|
||||
|
||||
}
|
||||
// GPIO_ClearBits(GPIOA, GPIO_Pin_7);
|
||||
}
|
||||
|
||||
|
||||
|
||||
//-- UART GPIO functions -------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Инициализация GPIO для UART0
|
||||
*/
|
||||
void uart0_gpio_init(void)
|
||||
{
|
||||
#if USE_UART0==1
|
||||
// Получаем структуры
|
||||
GPIO_Init_TypeDef *tx_config = gpio_get_init(UART0_GPIO_Port, UART0_Tx_Pin);
|
||||
GPIO_Init_TypeDef *rx_config = gpio_get_init(UART0_GPIO_Port, UART0_Rx_Pin);
|
||||
|
||||
// TX пин
|
||||
if (uart0_config.UART_Init.Tx == ENABLE && tx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(tx_config);
|
||||
tx_config->AltFunc = ENABLE;
|
||||
tx_config->Digital = ENABLE;
|
||||
tx_config->Pin = UART0_Tx_Pin;
|
||||
GPIO_Init(UART0_GPIO_Port, tx_config);
|
||||
}
|
||||
|
||||
// RX пин
|
||||
if (uart0_config.UART_Init.Rx == ENABLE && rx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->AltFunc = ENABLE;
|
||||
rx_config->Digital = ENABLE;
|
||||
rx_config->Pin = UART0_Rx_Pin;
|
||||
GPIO_Init(UART0_GPIO_Port, rx_config);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
/**
|
||||
* @brief Деинициализация GPIO для UART0
|
||||
*/
|
||||
void uart0_gpio_deinit(void)
|
||||
{
|
||||
#if USE_UART0==1
|
||||
// Получаем структуры
|
||||
GPIO_Init_TypeDef *tx_config = gpio_get_init(UART0_GPIO_Port, UART0_Tx_Pin);
|
||||
GPIO_Init_TypeDef *rx_config = gpio_get_init(UART0_GPIO_Port, UART0_Rx_Pin);
|
||||
|
||||
// Восстанавливаем оригинальные настройки из таблицы
|
||||
if (tx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->Pin = UART0_Tx_Pin;
|
||||
GPIO_Init(UART0_GPIO_Port, tx_config);
|
||||
}
|
||||
|
||||
if (rx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->Pin = UART0_Rx_Pin;
|
||||
GPIO_Init(UART0_GPIO_Port, rx_config);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
/**
|
||||
* @brief Инициализация GPIO для UART1
|
||||
*/
|
||||
void uart1_gpio_init(void)
|
||||
{
|
||||
#if USE_UART1==1
|
||||
// Получаем структуры
|
||||
GPIO_Init_TypeDef *tx_config = gpio_get_init(UART1_GPIO_Port, UART1_Tx_Pin);
|
||||
GPIO_Init_TypeDef *rx_config = gpio_get_init(UART1_GPIO_Port, UART1_Rx_Pin);
|
||||
|
||||
// TX пин
|
||||
if (uart1_config.UART_Init.Tx == ENABLE && tx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(tx_config);
|
||||
tx_config->AltFunc = ENABLE;
|
||||
tx_config->Digital = ENABLE;
|
||||
tx_config->Pin = UART1_Tx_Pin;
|
||||
GPIO_Init(UART1_GPIO_Port, tx_config);
|
||||
}
|
||||
|
||||
// RX пин
|
||||
if (uart1_config.UART_Init.Rx == ENABLE && rx_config != NULL)
|
||||
{
|
||||
;
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->AltFunc = ENABLE;
|
||||
rx_config->Digital = ENABLE;
|
||||
rx_config->Pin = UART1_Rx_Pin;
|
||||
GPIO_Init(UART1_GPIO_Port, rx_config);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
/**
|
||||
* @brief Деинициализация GPIO для UART1
|
||||
*/
|
||||
void uart1_gpio_deinit(void)
|
||||
{
|
||||
#if USE_UART1==1
|
||||
// Получаем структуры
|
||||
GPIO_Init_TypeDef *tx_config = gpio_get_init(UART1_GPIO_Port, UART1_Tx_Pin);
|
||||
GPIO_Init_TypeDef *rx_config = gpio_get_init(UART1_GPIO_Port, UART1_Rx_Pin);
|
||||
|
||||
// Восстанавливаем оригинальные настройки из таблицы
|
||||
if (tx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->Pin = UART1_Tx_Pin;
|
||||
GPIO_Init(UART1_GPIO_Port, tx_config);
|
||||
}
|
||||
|
||||
if (rx_config != NULL)
|
||||
{
|
||||
GPIO_StructInit(rx_config);
|
||||
rx_config->Pin = UART1_Rx_Pin;
|
||||
GPIO_Init(UART1_GPIO_Port, rx_config);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//-- UART private functions ----------------------------------------------------
|
||||
/**
|
||||
* @brief Приём данных из RX FIFO
|
||||
* @param huart указатель на хендл UART
|
||||
* @param it_mode режим работы (0 — polling, 1 — прерывания)
|
||||
* @retval int 1 — приём завершён, 0 — данные ещё принимаются
|
||||
*/
|
||||
static int __uart_fifo_receive(UART_HandleTypeDef *huart, uint8_t it_mode)
|
||||
{
|
||||
while (!UART_FlagStatus(huart->Instance, UART_Flag_RxFIFOEmpty) &&
|
||||
huart->RxCount < huart->RxSize)
|
||||
{
|
||||
huart->RxBufPtr[huart->RxCount++] = UART_RecieveData(huart->Instance);
|
||||
|
||||
if (huart->RxCount == huart->RxSize)
|
||||
{
|
||||
huart->RxBusy = 0;
|
||||
|
||||
if(it_mode)
|
||||
{
|
||||
// Выключаем RX прерывания
|
||||
UART_ITCmd(huart->Instance,
|
||||
UART_ITSource_RxFIFOLevel |
|
||||
UART_ITSource_RecieveTimeout,
|
||||
DISABLE);
|
||||
}
|
||||
|
||||
if (huart->Config->RxCallback)
|
||||
huart->Config->RxCallback();
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/**
|
||||
* @brief Передача данных в TX FIFO
|
||||
* @param huart указатель на хендл UART
|
||||
* @param it_mode режим работы (0 — polling, 1 — прерывания)
|
||||
* @retval int 1 — передача завершена, 0 — данные ещё передаются
|
||||
*/
|
||||
static int __uart_fifo_transmit(UART_HandleTypeDef *huart, uint8_t it_mode)
|
||||
{
|
||||
while (!UART_FlagStatus(huart->Instance, UART_Flag_TxFIFOFull) &&
|
||||
huart->TxCount < huart->TxSize)
|
||||
{
|
||||
UART_SendData(huart->Instance, huart->TxBufPtr[huart->TxCount++]);
|
||||
}
|
||||
|
||||
if (huart->TxCount == huart->TxSize)
|
||||
{
|
||||
if(it_mode)
|
||||
{
|
||||
// Выключаем FIFO прерывание
|
||||
UART_ITCmd(huart->Instance, UART_ITSource_TxFIFOLevel, DISABLE);
|
||||
// Включаем TransmitDone прерывание, коллбек будет по нему
|
||||
UART_ITCmd(huart->Instance, UART_ITSource_TransmitDone, ENABLE);
|
||||
}
|
||||
else
|
||||
{
|
||||
while(!UART_FlagStatus(huart->Instance, UART_Flag_TxFIFOEmpty)); // ждем пока не опустошится буфер
|
||||
|
||||
huart->TxBusy = 0;
|
||||
if (huart->Config->TxCallback)
|
||||
huart->Config->TxCallback();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if USE_TX_QUEUE==1
|
||||
static void __uart_tx_queue_process(UART_HandleTypeDef *huart)
|
||||
{
|
||||
if (!huart->TxBusy && !huart->TxQueue.QueueEmpty)
|
||||
{
|
||||
__uart_tx_queue_pop(huart);
|
||||
}
|
||||
}
|
||||
|
||||
static OperationStatus __uart_tx_queue_push(UART_HandleTypeDef *huart, const uint8_t *buf, uint16_t size)
|
||||
{
|
||||
if (!huart || !buf || size == 0 || huart->TxQueue.QueueFull)
|
||||
return ERROR;
|
||||
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueHead].Buf = buf;
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueHead].Size = size;
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueHead].InUse = 1;
|
||||
|
||||
huart->TxQueue.QueueHead = (huart->TxQueue.QueueHead + 1) % TX_QUEUE_SIZE;
|
||||
huart->TxQueue.QueueCount++;
|
||||
|
||||
huart->TxQueue.QueueEmpty = 0;
|
||||
if (huart->TxQueue.QueueCount == TX_QUEUE_SIZE)
|
||||
huart->TxQueue.QueueFull = 1;
|
||||
|
||||
return OK;
|
||||
}
|
||||
static OperationStatus __uart_tx_queue_pop(UART_HandleTypeDef *huart)
|
||||
{
|
||||
if (!huart || huart->TxQueue.QueueEmpty)
|
||||
return ERROR;
|
||||
|
||||
const uint8_t *buf = huart->TxQueue.Queue[huart->TxQueue.QueueTail].Buf;
|
||||
uint16_t size = huart->TxQueue.Queue[huart->TxQueue.QueueTail].Size;
|
||||
|
||||
if (huart->TxBusy)
|
||||
return ERROR;
|
||||
|
||||
huart->TxBufPtr = buf;
|
||||
huart->TxSize = size;
|
||||
huart->TxCount = 0;
|
||||
huart->TxBusy = 1;
|
||||
|
||||
UART_ITCmd(huart->Instance, UART_ITSource_TxFIFOLevel, ENABLE);
|
||||
__uart_fifo_transmit(huart, 1);
|
||||
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueTail].Buf = NULL;
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueTail].Size = 0;
|
||||
huart->TxQueue.Queue[huart->TxQueue.QueueTail].InUse = 0;
|
||||
|
||||
huart->TxQueue.QueueTail = (huart->TxQueue.QueueTail + 1) % TX_QUEUE_SIZE;
|
||||
huart->TxQueue.QueueCount--;
|
||||
|
||||
huart->TxQueue.QueueFull = 0;
|
||||
if (huart->TxQueue.QueueCount == 0)
|
||||
huart->TxQueue.QueueEmpty = 1;
|
||||
|
||||
return OK;
|
||||
}
|
||||
#endif
|
||||
166
MDK-ARM/Core/App/uart.h
Normal file
166
MDK-ARM/Core/App/uart.h
Normal file
@@ -0,0 +1,166 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file uart.h
|
||||
* @author Разваляев Алексей
|
||||
* @brief Драйвер UART на основе PLIB035.
|
||||
* Данный файл содержит определения типов, структур и прототипы функций
|
||||
* для работы с UART, включая:
|
||||
* + Структуры и typedef для UART
|
||||
* + Макросы для конфигурации направления передачи
|
||||
* + Прототипы функций для инициализации и API драйвера
|
||||
*
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
#ifndef __UART_H
|
||||
#define __UART_H
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
// Дефайны для режима направления UART
|
||||
// Дефайны для режима пина RxEnable, TxEnable
|
||||
/** @brief Направление: никакого */
|
||||
#define UART_Direction_None DISABLE, DISABLE
|
||||
/** @brief Направление: Rx и Tx */
|
||||
#define UART_Direction_RxTx ENABLE, ENABLE
|
||||
/** @brief Направление: только Tx */
|
||||
#define UART_Direction_Tx DISABLE, ENABLE
|
||||
/** @brief Направление: только Rx */
|
||||
#define UART_Direction_Rx ENABLE, DISABLE
|
||||
|
||||
// Дефайны для пинов UART
|
||||
#define UART0_Tx_Pin GPIO_Pin_10 /**< PB10 — UART0 Tx */
|
||||
#define UART0_Rx_Pin GPIO_Pin_11 /**< PB11 — UART0 Rx */
|
||||
#define UART0_GPIO_Port GPIOB /**< GPIO порт UART0 */
|
||||
|
||||
#define UART1_Tx_Pin GPIO_Pin_8 /**< PB8 — UART1 Tx */
|
||||
#define UART1_Rx_Pin GPIO_Pin_9 /**< PB9 — UART1 Rx */
|
||||
#define UART1_GPIO_Port GPIOB /**< GPIO порт UART1 */
|
||||
|
||||
#define USE_TX_QUEUE 1 /*!< Использовать очередь для отправки, чтобы не терять данные */
|
||||
#define TX_QUEUE_SIZE 32 /*!< Размер очереди в кол-ве буферов для отправки */
|
||||
|
||||
//-- Types ---------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @brief Типы callback-функций UART
|
||||
*/
|
||||
typedef enum
|
||||
{
|
||||
UART_Callback_Rx, /*!< Приём данных завершён */
|
||||
UART_Callback_Tx, /*!< Передача данных завершена */
|
||||
UART_Callback_Idle, /*!< Обнаружено состояние IDLE */
|
||||
UART_Callback_Error, /*!< Ошибка UART */
|
||||
|
||||
} UART_CallbackTypeDef;
|
||||
|
||||
|
||||
/**
|
||||
* @brief Расширенная конфигурация UART
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
UART_Init_TypeDef UART_Init; /*!< Стандартная конфигурация UART из PLIB */
|
||||
|
||||
/* Callback функции */
|
||||
void (*RxCallback)(void); /*!< Вызывается при приёме полного сообщения */
|
||||
void (*TxCallback)(void); /*!< Вызывается при окончании передачи */
|
||||
void (*IdleCallback)(void); /*!< Вызывается при IDLE линии RX */
|
||||
void (*ErrCallback)(void); /*!< Вызывается при ошибке UART */
|
||||
|
||||
} UART_ExtInit_TypeDef;
|
||||
|
||||
|
||||
/**
|
||||
* @brief Структура элемента очереди
|
||||
*/
|
||||
typedef struct {
|
||||
const uint8_t *Buf; /*!< Указатель на буфер данных */
|
||||
uint16_t Size; /*!< Размер данных в буфере */
|
||||
uint8_t InUse; /*!< Флаг занятости элемента */
|
||||
} UART_QueueItemTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Структура очереди UART
|
||||
*/
|
||||
typedef struct {
|
||||
UART_QueueItemTypeDef Queue[TX_QUEUE_SIZE]; /*!< Циклический буфер очереди */
|
||||
uint8_t QueueHead; /*!< Индекс головы очереди (куда добавляем) */
|
||||
uint8_t QueueTail; /*!< Индекс хвоста очереди (откуда берем) */
|
||||
uint8_t QueueCount; /*!< Количество элементов в очереди */
|
||||
uint8_t QueueEmpty; /*!< Флаг пустой очереди */
|
||||
uint8_t QueueFull; /*!< Флаг полной очереди */
|
||||
} UART_TxQueueTypeDef;
|
||||
|
||||
/**
|
||||
* @brief Хендл UART
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
UART_TypeDef *Instance; /*!< Регистры UART */
|
||||
UART_ExtInit_TypeDef *Config; /*!< Конфигурация UART */
|
||||
|
||||
/* ===== TX ===== */
|
||||
const uint8_t *TxBufPtr; /*!< Указатель на буфер передачи */
|
||||
uint16_t TxCount; /*!< Счётчик переданных байт */
|
||||
uint16_t TxSize; /*!< Размер передаваемых данных */
|
||||
volatile uint8_t TxBusy; /*!< Флаг занятости TX */
|
||||
|
||||
/* ===== RX ===== */
|
||||
uint8_t *RxBufPtr; /*!< Указатель на буфер приёма */
|
||||
uint16_t RxCount; /*!< Счётчик принятых байт */
|
||||
uint16_t RxSize; /*!< Размер принимаемых данных */
|
||||
volatile uint8_t RxBusy; /*!< Флаг занятости RX */
|
||||
|
||||
#if (USE_TX_QUEUE==1)
|
||||
/* == TX QUEUE == */
|
||||
UART_TxQueueTypeDef TxQueue;
|
||||
#endif
|
||||
|
||||
} UART_HandleTypeDef;
|
||||
|
||||
//-- External handles ----------------------------------------------------------
|
||||
|
||||
extern UART_HandleTypeDef huart0;
|
||||
extern UART_HandleTypeDef huart1;
|
||||
|
||||
//-- Exported functions prototypes ---------------------------------------------
|
||||
|
||||
/* Init functions */
|
||||
|
||||
/* Первичная инициализация UART (UART0 / UART1) */
|
||||
void uart_init_first(void);
|
||||
/* Инициализация UARTx */
|
||||
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInit_TypeDef *NewConfig);
|
||||
/* Общий обработчик прерываний UART */
|
||||
void uart_irq_handler(UART_HandleTypeDef *huart);
|
||||
/* Инициализация GPIO для UART0 */
|
||||
void uart0_gpio_init(void);
|
||||
/* Деинициализация GPIO для UART0 */
|
||||
void uart0_gpio_deinit(void);
|
||||
/* Инициализация GPIO для UART1 */
|
||||
void uart1_gpio_init(void);
|
||||
/* Деинициализация GPIO для UART1 */
|
||||
void uart1_gpio_deinit(void);
|
||||
|
||||
/* API functions*/
|
||||
|
||||
/* Установка callback-функции UART */
|
||||
OperationStatus UART_Set_Callback(UART_HandleTypeDef *huart, UART_CallbackTypeDef CallbackType, void (*Callback)(void));
|
||||
/* Запуск UART и настройка FIFO */
|
||||
OperationStatus UART_Start(UART_HandleTypeDef *huart, UART_FIFOLevel_TypeDef TxFifoLevel, UART_FIFOLevel_TypeDef RxFifoLevel);
|
||||
|
||||
/* Передача данных по UART (блокирующий режим) */
|
||||
OperationStatus UART_Transmit(UART_HandleTypeDef *huart, uint8_t *buf, uint16_t size, uint32_t timeout);
|
||||
/* Приём данных по UART (блокирующий режим) */
|
||||
OperationStatus UART_Receive(UART_HandleTypeDef *huart, uint8_t *buf, uint16_t size, uint32_t timeout);
|
||||
/* Передача данных по UART (режим прерываний) */
|
||||
OperationStatus UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *buf, uint16_t size);
|
||||
/* Приём данных по UART (режим прерываний) */
|
||||
OperationStatus UART_Receive_IT(UART_HandleTypeDef *huart, uint8_t *buf, uint16_t size);
|
||||
|
||||
|
||||
|
||||
#endif /*__UART_H*/
|
||||
412
MDK-ARM/Core/App/vk035_it.c
Normal file
412
MDK-ARM/Core/App/vk035_it.c
Normal file
@@ -0,0 +1,412 @@
|
||||
/**
|
||||
******************************************************************************
|
||||
* @file vk035_it.c
|
||||
* @author Разваляев Алексей
|
||||
* @brief Обработчики прерываний для микроконтроллера 1921ВК035.
|
||||
* Этот файл содержит:
|
||||
* + Обработчики прерываний периферии (UART, TMR, ADC, DMA и др.)
|
||||
* + Обработчики исключений Cortex-M4 (HardFault, SysTick и др.)
|
||||
* + Интеграцию с драйверами периферии через вызовы обработчиков
|
||||
* + Управление системным временем через SysTick
|
||||
*
|
||||
******************************************************************************
|
||||
* @attention
|
||||
*
|
||||
* Использование этого файла предполагает наличие корректных настроек:
|
||||
* - Определены USE_xxx макросы в periph_config.h для включения периферии
|
||||
* - Инициализированы соответствующие драйверы периферии
|
||||
* - Включены прерывания в NVIC через функции драйверов
|
||||
*
|
||||
******************************************************************************
|
||||
* @verbatim
|
||||
==============================================================================
|
||||
##### Как использовать этот файл #####
|
||||
==============================================================================
|
||||
|
||||
1. Настройка периферии (periph_config.h):
|
||||
(+) Определить USE_TMRx для используемых таймеров (0-3)
|
||||
(+) Определить USE_UARTx для используемых UART (0-1)
|
||||
(+) Определить USE_ADC_SEQx для используемых секвенсоров ADC (0-1)
|
||||
|
||||
2. Инициализация драйверов:
|
||||
(+) Вызвать функции инициализации драйверов (uart_init_first, tmr_init_first и т.д.)
|
||||
- Драйверы автоматически включат соответствующие прерывания в NVIC
|
||||
|
||||
3. Обработка прерываний:
|
||||
(+) Прерывания периферии автоматически перенаправляются в драйверы
|
||||
(+) Системные прерывания (SysTick) управляют временем millis/micros
|
||||
(+) Обработчики исключений обрабатывают критические ошибки
|
||||
|
||||
4. Интеграция с драйверами:
|
||||
(+) UART прерывания -> uart_irq_handler(&huartx)
|
||||
(+) TMR прерывания -> tmr_irq_handler(&htmrx)
|
||||
(+) ADC SEQ прерывания -> adc_seq_irq_handler(&hadc, SEQ_Num)
|
||||
|
||||
5. Системное время:
|
||||
(+) SysTick_Handler() автоматически обновляет millis() и micros()
|
||||
(+) Период SysTick настраивается в sysclk_init()
|
||||
|
||||
6. Особенности работы:
|
||||
(+) Неиспользуемые обработчики оставлены пустыми для будущего расширения
|
||||
(+) Критические ошибки (HardFault и др.) уходят в бесконечный цикл
|
||||
(+) Прерывания обрабатываются неблокирующе с минимальными задержками
|
||||
|
||||
@endverbatim
|
||||
******************************************************************************
|
||||
*/
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "main.h"
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* 1921VK035 Peripheral Interrupt Handlers */
|
||||
/* Add here the Interrupt Handlers for the used peripherals. */
|
||||
/******************************************************************************/
|
||||
#if USE_WDT==1
|
||||
void WDT_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
void GPIOA_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void GPIOB_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#if USE_TMR0==1
|
||||
void TMR0_IRQHandler(void)
|
||||
{
|
||||
tmr_irq_handler(&htmr0);
|
||||
}
|
||||
#endif
|
||||
#if USE_TMR1==1
|
||||
void TMR1_IRQHandler(void)
|
||||
{
|
||||
tmr_irq_handler(&htmr1);
|
||||
}
|
||||
#endif
|
||||
#if USE_TMR2==1
|
||||
void TMR2_IRQHandler(void)
|
||||
{
|
||||
tmr_irq_handler(&htmr2);
|
||||
}
|
||||
#endif
|
||||
#if USE_TMR3==1
|
||||
void TMR3_IRQHandler(void)
|
||||
{
|
||||
tmr_irq_handler(&htmr3);
|
||||
}
|
||||
#endif
|
||||
#if USE_UART0==1
|
||||
void UART0_TD_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart0);
|
||||
}
|
||||
void UART0_RX_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart0);
|
||||
}
|
||||
void UART0_TX_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart0);
|
||||
}
|
||||
void UART0_E_RT_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart0);
|
||||
}
|
||||
#endif
|
||||
#if USE_UART1==1
|
||||
void UART1_TD_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart1);
|
||||
}
|
||||
void UART1_RX_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart1);
|
||||
}
|
||||
void UART1_TX_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart1);
|
||||
}
|
||||
void UART1_E_RT_IRQHandler(void)
|
||||
{
|
||||
uart_irq_handler(&huart1);
|
||||
}
|
||||
#endif
|
||||
#if USE_SPI==1
|
||||
void SPI_RO_RT_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void SPI_RX_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void SPI_TX_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_I2C==1
|
||||
void I2C_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_ECAP0==1
|
||||
void ECAP0_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_ECAP1==1
|
||||
void ECAP1_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_ECAP2==1
|
||||
void ECAP2_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_PWM0==1
|
||||
void PWM0_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM0_HD_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM0_TZ_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_PWM1==1
|
||||
void PWM1_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM1_HD_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM1_TZ_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_PWM2==1
|
||||
void PWM2_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM2_HD_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void PWM2_TZ_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_QEP==1
|
||||
void QEP_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_ADC_SEQ0==1
|
||||
void ADC_SEQ0_IRQHandler(void)
|
||||
{
|
||||
adc_seq_irq_handler(&hadc, ADC_SEQ_Num_0);
|
||||
}
|
||||
#endif
|
||||
#if USE_ADC_SEQ1==1
|
||||
void ADC_SEQ1_IRQHandler(void)
|
||||
{
|
||||
adc_seq_irq_handler(&hadc, ADC_SEQ_Num_1);
|
||||
}
|
||||
#endif
|
||||
#if (USE_ADC_DC0==1) || (USE_ADC_DC1==1) || (USE_ADC_DC2==1) || (USE_ADC_DC3==1)
|
||||
void ADC_DC_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
#if USE_ADC_CAN==1
|
||||
void CAN0_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN1_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN2_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN3_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN4_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN5_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN6_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN7_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN8_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN9_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN10_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN11_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN12_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN13_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN14_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void CAN15_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
void DMA_CH0_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH1_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH2_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH3_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH4_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH5_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH6_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH7_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH8_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH9_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH10_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH11_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH12_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH13_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH14_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void DMA_CH15_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void FPU_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void RCU_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
void MFLASH_IRQHandler(void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************/
|
||||
/* Cortex-M4 Processor Interruption and Exception Handlers */
|
||||
/******************************************************************************/
|
||||
/**
|
||||
* @brief This function handles Non maskable interrupt.
|
||||
*/
|
||||
void NMI_Handler(void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Hard fault interrupt.
|
||||
*/
|
||||
void HardFault_Handler(void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Memory management fault.
|
||||
*/
|
||||
void MemManage_Handler(void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Prefetch fault, memory access fault.
|
||||
*/
|
||||
void BusFault_Handler(void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Undefined instruction or illegal state.
|
||||
*/
|
||||
void UsageFault_Handler(void)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles System service call via SWI instruction.
|
||||
*/
|
||||
void SVC_Handler(void)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Debug monitor.
|
||||
*/
|
||||
void DebugMon_Handler(void)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles Pendable request for system service.
|
||||
*/
|
||||
void PendSV_Handler(void)
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function handles System tick timer.
|
||||
*/
|
||||
void SysTick_Handler(void)
|
||||
{
|
||||
sysclk_irq_handler();
|
||||
}
|
||||
429
MDK-ARM/Core/Config/SEGGER_RTT_Conf.h
Normal file
429
MDK-ARM/Core/Config/SEGGER_RTT_Conf.h
Normal file
@@ -0,0 +1,429 @@
|
||||
/*********************************************************************
|
||||
* SEGGER Microcontroller GmbH *
|
||||
* The Embedded Experts *
|
||||
**********************************************************************
|
||||
* *
|
||||
* (c) 1995 - 2021 SEGGER Microcontroller GmbH *
|
||||
* *
|
||||
* www.segger.com Support: support@segger.com *
|
||||
* *
|
||||
**********************************************************************
|
||||
* *
|
||||
* SEGGER RTT * Real Time Transfer for embedded targets *
|
||||
* *
|
||||
**********************************************************************
|
||||
* *
|
||||
* All rights reserved. *
|
||||
* *
|
||||
* SEGGER strongly recommends to not make any changes *
|
||||
* to or modify the source code of this software in order to stay *
|
||||
* compatible with the RTT protocol and J-Link. *
|
||||
* *
|
||||
* Redistribution and use in source and binary forms, with or *
|
||||
* without modification, are permitted provided that the following *
|
||||
* condition is met: *
|
||||
* *
|
||||
* o Redistributions of source code must retain the above copyright *
|
||||
* notice, this condition and the following disclaimer. *
|
||||
* *
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND *
|
||||
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, *
|
||||
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF *
|
||||
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE *
|
||||
* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
|
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR *
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT *
|
||||
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; *
|
||||
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
|
||||
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT *
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE *
|
||||
* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH *
|
||||
* DAMAGE. *
|
||||
* *
|
||||
**********************************************************************
|
||||
* *
|
||||
* RTT version: 8.10g *
|
||||
* *
|
||||
**********************************************************************
|
||||
|
||||
---------------------------END-OF-HEADER------------------------------
|
||||
File : SEGGER_RTT_Conf.h
|
||||
Purpose : Implementation of SEGGER real-time transfer (RTT) which
|
||||
allows real-time communication on targets which support
|
||||
debugger memory accesses while the CPU is running.
|
||||
Revision: $Rev: 24316 $
|
||||
|
||||
*/
|
||||
|
||||
#ifndef SEGGER_RTT_CONF_H
|
||||
#define SEGGER_RTT_CONF_H
|
||||
|
||||
#ifdef __IAR_SYSTEMS_ICC__
|
||||
#include <intrinsics.h>
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* Defines, configurable
|
||||
*
|
||||
**********************************************************************
|
||||
*/
|
||||
|
||||
//
|
||||
// Take in and set to correct values for Cortex-A systems with CPU cache
|
||||
//
|
||||
//#define SEGGER_RTT_CPU_CACHE_LINE_SIZE (32) // Largest cache line size (in bytes) in the current system
|
||||
//#define SEGGER_RTT_UNCACHED_OFF (0xFB000000) // Address alias where RTT CB and buffers can be accessed uncached
|
||||
//
|
||||
// Most common case:
|
||||
// Up-channel 0: RTT
|
||||
// Up-channel 1: SystemView
|
||||
//
|
||||
#ifndef SEGGER_RTT_MAX_NUM_UP_BUFFERS
|
||||
#define SEGGER_RTT_MAX_NUM_UP_BUFFERS (3) // Max. number of up-buffers (T->H) available on this target (Default: 3)
|
||||
#endif
|
||||
//
|
||||
// Most common case:
|
||||
// Down-channel 0: RTT
|
||||
// Down-channel 1: SystemView
|
||||
//
|
||||
#ifndef SEGGER_RTT_MAX_NUM_DOWN_BUFFERS
|
||||
#define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (3) // Max. number of down-buffers (H->T) available on this target (Default: 3)
|
||||
#endif
|
||||
|
||||
#ifndef BUFFER_SIZE_UP
|
||||
#define BUFFER_SIZE_UP (4096) // Size of the buffer for terminal output of target, up to host (Default: 1k)
|
||||
#endif
|
||||
|
||||
#ifndef BUFFER_SIZE_DOWN
|
||||
#define BUFFER_SIZE_DOWN (16) // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)
|
||||
#endif
|
||||
|
||||
#ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE
|
||||
#define SEGGER_RTT_PRINTF_BUFFER_SIZE (64u) // Size of buffer for RTT printf to bulk-send chars via RTT (Default: 64)
|
||||
#endif
|
||||
|
||||
#ifndef SEGGER_RTT_MODE_DEFAULT
|
||||
#define SEGGER_RTT_MODE_DEFAULT SEGGER_RTT_MODE_NO_BLOCK_TRIM // Mode for pre-initialized terminal channel (buffer 0)
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT memcpy configuration
|
||||
*
|
||||
* memcpy() is good for large amounts of data,
|
||||
* but the overhead is big for small amounts, which are usually stored via RTT.
|
||||
* With SEGGER_RTT_MEMCPY_USE_BYTELOOP a simple byte loop can be used instead.
|
||||
*
|
||||
* SEGGER_RTT_MEMCPY() can be used to replace standard memcpy() in RTT functions.
|
||||
* This is may be required with memory access restrictions,
|
||||
* such as on Cortex-A devices with MMU.
|
||||
*/
|
||||
#ifndef SEGGER_RTT_MEMCPY_USE_BYTELOOP
|
||||
#define SEGGER_RTT_MEMCPY_USE_BYTELOOP 0 // 0: Use memcpy/SEGGER_RTT_MEMCPY, 1: Use a simple byte-loop
|
||||
#endif
|
||||
//
|
||||
// Example definition of SEGGER_RTT_MEMCPY to external memcpy with GCC toolchains and Cortex-A targets
|
||||
//
|
||||
//#if ((defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)) && (defined (__ARM_ARCH_7A__))
|
||||
// #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes) SEGGER_memcpy((pDest), (pSrc), (NumBytes))
|
||||
//#endif
|
||||
|
||||
//
|
||||
// Target is not allowed to perform other RTT operations while string still has not been stored completely.
|
||||
// Otherwise we would probably end up with a mixed string in the buffer.
|
||||
// If using RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here.
|
||||
//
|
||||
// SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4.
|
||||
// Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches.
|
||||
// When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly.
|
||||
// (Higher priority = lower priority number)
|
||||
// Default value for embOS: 128u
|
||||
// Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
|
||||
// In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC
|
||||
// or define SEGGER_RTT_LOCK() to completely disable interrupts.
|
||||
//
|
||||
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
|
||||
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20) // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20)
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for SEGGER Embedded Studio,
|
||||
* Rowley CrossStudio and GCC
|
||||
*/
|
||||
#if ((defined(__SES_ARM) || defined(__SES_RISCV) || defined(__CROSSWORKS_ARM) || defined(__GNUC__) || defined(__clang__)) && !defined (__CC_ARM) && !defined(WIN32))
|
||||
#if (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__))
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
__asm volatile ("mrs %0, primask \n\t" \
|
||||
"movs r1, #1 \n\t" \
|
||||
"msr primask, r1 \n\t" \
|
||||
: "=r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
: "r1", "cc" \
|
||||
);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __asm volatile ("msr primask, %0 \n\t" \
|
||||
: \
|
||||
: "r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
); \
|
||||
}
|
||||
#elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__) || defined(__ARM_ARCH_8_1M_MAIN__))
|
||||
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
|
||||
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
|
||||
#endif
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
__asm volatile ("mrs %0, basepri \n\t" \
|
||||
"mov r1, %1 \n\t" \
|
||||
"msr basepri, r1 \n\t" \
|
||||
: "=r" (_SEGGER_RTT__LockState) \
|
||||
: "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY) \
|
||||
: "r1", "cc" \
|
||||
);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __asm volatile ("msr basepri, %0 \n\t" \
|
||||
: \
|
||||
: "r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
); \
|
||||
}
|
||||
|
||||
#elif (defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__))
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
__asm volatile ("mrs r1, CPSR \n\t" \
|
||||
"mov %0, r1 \n\t" \
|
||||
"orr r1, r1, #0xC0 \n\t" \
|
||||
"msr CPSR_c, r1 \n\t" \
|
||||
: "=r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
: "r1", "cc" \
|
||||
);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \
|
||||
"mrs r1, CPSR \n\t" \
|
||||
"bic r1, r1, #0xC0 \n\t" \
|
||||
"and r0, r0, #0xC0 \n\t" \
|
||||
"orr r1, r1, r0 \n\t" \
|
||||
"msr CPSR_c, r1 \n\t" \
|
||||
: \
|
||||
: "r" (_SEGGER_RTT__LockState) \
|
||||
: "r0", "r1", "cc" \
|
||||
); \
|
||||
}
|
||||
#elif defined(__riscv) || defined(__riscv_xlen)
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
__asm volatile ("csrr %0, mstatus \n\t" \
|
||||
"csrci mstatus, 8 \n\t" \
|
||||
"andi %0, %0, 8 \n\t" \
|
||||
: "=r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
: \
|
||||
);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __asm volatile ("csrr a1, mstatus \n\t" \
|
||||
"or %0, %0, a1 \n\t" \
|
||||
"csrs mstatus, %0 \n\t" \
|
||||
: \
|
||||
: "r" (_SEGGER_RTT__LockState) \
|
||||
: "a1" \
|
||||
); \
|
||||
}
|
||||
#else
|
||||
#define SEGGER_RTT_LOCK()
|
||||
#define SEGGER_RTT_UNLOCK()
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for IAR EWARM
|
||||
*/
|
||||
#ifdef __ICCARM__
|
||||
#if (defined (__ARM6M__) && (__CORE__ == __ARM6M__)) || \
|
||||
(defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__))
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = __get_PRIMASK(); \
|
||||
__set_PRIMASK(1);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#elif (defined (__ARM7EM__) && (__CORE__ == __ARM7EM__)) || \
|
||||
(defined (__ARM7M__) && (__CORE__ == __ARM7M__)) || \
|
||||
(defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__)) || \
|
||||
(defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__))
|
||||
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
|
||||
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
|
||||
#endif
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = __get_BASEPRI(); \
|
||||
__set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __set_BASEPRI(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#elif (defined (__ARM7A__) && (__CORE__ == __ARM7A__)) || \
|
||||
(defined (__ARM7R__) && (__CORE__ == __ARM7R__))
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
__asm volatile ("mrs r1, CPSR \n\t" \
|
||||
"mov %0, r1 \n\t" \
|
||||
"orr r1, r1, #0xC0 \n\t" \
|
||||
"msr CPSR_c, r1 \n\t" \
|
||||
: "=r" (_SEGGER_RTT__LockState) \
|
||||
: \
|
||||
: "r1", "cc" \
|
||||
);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t" \
|
||||
"mrs r1, CPSR \n\t" \
|
||||
"bic r1, r1, #0xC0 \n\t" \
|
||||
"and r0, r0, #0xC0 \n\t" \
|
||||
"orr r1, r1, r0 \n\t" \
|
||||
"msr CPSR_c, r1 \n\t" \
|
||||
: \
|
||||
: "r" (_SEGGER_RTT__LockState) \
|
||||
: "r0", "r1", "cc" \
|
||||
); \
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for IAR RX
|
||||
*/
|
||||
#ifdef __ICCRX__
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned long _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = __get_interrupt_state(); \
|
||||
__disable_interrupt();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for IAR RL78
|
||||
*/
|
||||
#ifdef __ICCRL78__
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
__istate_t _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = __get_interrupt_state(); \
|
||||
__disable_interrupt();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __set_interrupt_state(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for KEIL ARM
|
||||
*/
|
||||
#ifdef __CC_ARM
|
||||
#if (defined __TARGET_ARCH_6S_M)
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
register unsigned char _SEGGER_RTT__PRIMASK __asm( "primask"); \
|
||||
_SEGGER_RTT__LockState = _SEGGER_RTT__PRIMASK; \
|
||||
_SEGGER_RTT__PRIMASK = 1u; \
|
||||
__schedule_barrier();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() _SEGGER_RTT__PRIMASK = _SEGGER_RTT__LockState; \
|
||||
__schedule_barrier(); \
|
||||
}
|
||||
#elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))
|
||||
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
|
||||
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
|
||||
#endif
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
register unsigned char BASEPRI __asm( "basepri"); \
|
||||
_SEGGER_RTT__LockState = BASEPRI; \
|
||||
BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY; \
|
||||
__schedule_barrier();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() BASEPRI = _SEGGER_RTT__LockState; \
|
||||
__schedule_barrier(); \
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for TI ARM
|
||||
*/
|
||||
#ifdef __TI_ARM__
|
||||
#if defined (__TI_ARM_V6M0__)
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = __get_PRIMASK(); \
|
||||
__set_PRIMASK(1);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() __set_PRIMASK(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__))
|
||||
#ifndef SEGGER_RTT_MAX_INTERRUPT_PRIORITY
|
||||
#define SEGGER_RTT_MAX_INTERRUPT_PRIORITY (0x20)
|
||||
#endif
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned int _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = _set_interrupt_priority(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() _set_interrupt_priority(_SEGGER_RTT__LockState); \
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for CCRX
|
||||
*/
|
||||
#ifdef __RX
|
||||
#include <machine.h>
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
unsigned long _SEGGER_RTT__LockState; \
|
||||
_SEGGER_RTT__LockState = get_psw() & 0x010000; \
|
||||
clrpsw_i();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() set_psw(get_psw() | _SEGGER_RTT__LockState); \
|
||||
}
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration for embOS Simulation on Windows
|
||||
* (Can also be used for generic RTT locking with embOS)
|
||||
*/
|
||||
#if defined(WIN32) || defined(SEGGER_RTT_LOCK_EMBOS)
|
||||
|
||||
void OS_SIM_EnterCriticalSection(void);
|
||||
void OS_SIM_LeaveCriticalSection(void);
|
||||
|
||||
#define SEGGER_RTT_LOCK() { \
|
||||
OS_SIM_EnterCriticalSection();
|
||||
|
||||
#define SEGGER_RTT_UNLOCK() OS_SIM_LeaveCriticalSection(); \
|
||||
}
|
||||
#endif
|
||||
|
||||
/*********************************************************************
|
||||
*
|
||||
* RTT lock configuration fallback
|
||||
*/
|
||||
#ifndef SEGGER_RTT_LOCK
|
||||
#define SEGGER_RTT_LOCK() // Lock RTT (nestable) (i.e. disable interrupts)
|
||||
#endif
|
||||
|
||||
#ifndef SEGGER_RTT_UNLOCK
|
||||
#define SEGGER_RTT_UNLOCK() // Unlock RTT (nestable) (i.e. enable previous interrupt lock state)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
/*************************** End of file ****************************/
|
||||
131
MDK-ARM/Core/Config/mylibs_config.h
Normal file
131
MDK-ARM/Core/Config/mylibs_config.h
Normal file
@@ -0,0 +1,131 @@
|
||||
/**
|
||||
**************************************************************************
|
||||
* @file mylibs_config.h
|
||||
* @brief Конфигурации для библиотек MyLibs
|
||||
**************************************************************************
|
||||
* @defgroup MYLIBS_CONFIG Configs
|
||||
* @ingroup MYLIBS_ALL
|
||||
* @brief Конфигурации для библиотек MyLibs
|
||||
* @{
|
||||
*************************************************************************/
|
||||
#ifndef __MYLIBS_CONFIG_H_
|
||||
#define __MYLIBS_CONFIG_H_
|
||||
#include "plib035.h"
|
||||
#include "retarget_conf.h"
|
||||
|
||||
// user includes
|
||||
|
||||
/**
|
||||
* @addtogroup TRACE_CONFIG Trace configs
|
||||
* @ingroup MYLIBS_CONFIG
|
||||
* @brief Конфигурация трекеров и трассировки
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define TRACKERS_ENABLE ///< Включить трекеры
|
||||
#define SERIAL_TRACE_ENABLE ///< Включить serial трассировку
|
||||
#define RTT_TRACE_ENABLE ///< Включить serial трассировку через RTT
|
||||
//#define SWO_TRACE_ENABLE ///< Включить serial трассировку через SWO
|
||||
/**
|
||||
* @brief Уровень log serial трассировки @ref log_printf
|
||||
* - LOG_LEVEL == 0 - логирование отключено (макрос пустой)
|
||||
* - LOG_LEVEL == 1 - выводится время и TAG
|
||||
* - LOG_LEVEL >= 2 - выводится время, TAG, имя файла и номер строки
|
||||
*/
|
||||
#define LOG_LEVEL 1
|
||||
|
||||
#define RTT_FLASH_BUFFER_SIZE 1024 ///< Размер буфера RTT в Flash
|
||||
#define RTT_FLASH_SECTOR FLASH_SECTOR_11 ///< Сектор FLASH куда положится RTT буфер
|
||||
#define RTT_FLASH_SECTOR_START 0x080E0000 ///< Начало сектора RTT_FLASH_SECTOR
|
||||
#define RTT_FLASH_SECTOR_END 0x080FFFFF ///< Конец сектора RTT_FLASH_SECTOR
|
||||
|
||||
|
||||
#define HARDFAULT_SERIAL_TRACE ///< Включить обработку и serial трассировку Hardfault
|
||||
#define HF_RTT_TAG_BASE 0xDEAD0000 ///< базовый тег для HardFault
|
||||
#define HF_RTT_TAIL_SIZE RTT_FLASH_BUFFER_SIZE ///< Размер буфера RTT, который сохранится при Hardfault
|
||||
#define HF_STACK_DUMP_WORDS 32 ///< Сколько слов стека будет проанализировано во время Hardfault
|
||||
#define HF_FLASH_ADDR ((uint32_t)0x080FF000) ///< Адрес FLASH куда положится RTT буфер
|
||||
#define HF_RAM_END 0x20030000 ///< Конец RAM памяти (чтобы во время анализа стека не выйти за пределы)
|
||||
|
||||
#define GPIO_TRACE_ENABLE ///< Включить GPIO трассировку
|
||||
|
||||
/** TRACE_CONFIG
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup FILTER_CONFIG Filter configs
|
||||
* @ingroup MYLIBS_CONFIG
|
||||
* @brief Конфигурация фильтров
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
#define FILTERS_ENABLE ///< Включить библиотеку фильтров
|
||||
//#define FILTER_MEDIAN_MAX_SIZE ///< Максимальный размер окна медианного фильтра (по умолчанию 5)
|
||||
//#define FILTER_AVERAGE_MAX_SIZE ///< Максимальный размер окна усредняющего фильтра (по умолчанию 8)
|
||||
//#define FILTER_POLY_MAX_ORDER ///< Максимальный порядок полинома (по умолчанию 4)
|
||||
#define FILTERS_DISABLE_MOVING_AVERAGE
|
||||
/** GEN_CONFIG
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup GEN_CONFIG Genetic configs
|
||||
* @ingroup MYLIBS_CONFIG
|
||||
* @brief Конфигурация генетического алгоритма обучения
|
||||
* @{
|
||||
*/
|
||||
|
||||
#define GEN_OPTIMIZATION_ENABLE ///< Включить оптимизацию параметров
|
||||
#define GEN_MAX_PARAMS 20 ///< Максимальное количество параметров
|
||||
#define GEN_MAX_CANDIDATES 100 ///< Максимальное количество кандидатов для обучения
|
||||
|
||||
/** GEN_CONFIG
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup GEN_CONFIG Genetic configs
|
||||
* @ingroup MYLIBS_CONFIG
|
||||
* @brief Конфигурация генетического алгоритма обучения
|
||||
* @{
|
||||
*/
|
||||
|
||||
|
||||
#define BENCH_TIME_ENABLE ///< Включить бенч времени
|
||||
#define BENCH_TIME_MAX_CHANNELS 16 ///< Максимальное количество каналов измерения
|
||||
|
||||
/** GEN_CONFIG
|
||||
* @}
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @addtogroup LIBS_CONFIG Libraries configs
|
||||
* @ingroup MYLIBS_CONFIG
|
||||
* @brief Подключение различных модулей библиотеки
|
||||
* @{
|
||||
*/
|
||||
#define local_time() millis() ///< Локальное время
|
||||
|
||||
#define INCLUDE_FILTERS ///< Подключить библиотеку с фильтрами
|
||||
#define INCLUDE_GEN_OPTIMIZER ///< Подключить библиотеку для оптимизации параметров
|
||||
#define INCLUDE_BIT_ACCESS_LIB ///< Подключить библиотеку с typedef с битовыми полями
|
||||
#define INCLUDE_TRACKERS_LIB ///< Подключить библиотеку с трекерами
|
||||
#define INCLUDE_TRACE_LIB ///< Подключить библиотеку с трейсами
|
||||
#define INCLUDE_BENCH_TIME ///< Подключить библиотеку с бенчмарком времени
|
||||
//#define FREERTOS_DELAY ///< Использовать FreeRTOS задержку, вместо HAL
|
||||
|
||||
/** LIBS_CONFIG
|
||||
* @}
|
||||
*/
|
||||
|
||||
/** MYLIBS_CONFIG
|
||||
* @}
|
||||
*/
|
||||
#endif //__MYLIBS_CONFIG_H_
|
||||
141
MDK-ARM/Core/Config/mylibs_include.h
Normal file
141
MDK-ARM/Core/Config/mylibs_include.h
Normal file
@@ -0,0 +1,141 @@
|
||||
/**
|
||||
**************************************************************************
|
||||
* @file mylibs_include.h
|
||||
* @brief Заголочный файл для всех библиотек
|
||||
**************************************************************************
|
||||
* @details
|
||||
Здесь нужно собрать библиотеки и дефайны, которые должны быть видны во всем проекте,
|
||||
чтобы не подключать 100 инклюдов в каждом ".c" файле
|
||||
**************************************************************************
|
||||
* @defgroup MYLIBS_ALL My Libs
|
||||
* @brief Все используемые MyLibs библиотеки
|
||||
* @details
|
||||
Для подключения библиотеки необходимо:
|
||||
- Сконфигурировать mylibs_config.h:
|
||||
- Подключить заголовочный файл HAL библиотеки конкретного МК (напр. stm32f4xx_hal.h)
|
||||
- Подключить другие заголовочные файлы которые общие для всего проекта и должны быть видны
|
||||
- Подключить mylibs_include.h туда, где необходим доступ к библиотекам.
|
||||
|
||||
*************************************************************************/
|
||||
#ifndef __MYLIBS_INCLUDE_H_
|
||||
#define __MYLIBS_INCLUDE_H_
|
||||
|
||||
#include "mylibs_defs.h"
|
||||
|
||||
|
||||
#ifdef ARM_MATH_CM4
|
||||
#include "arm_math.h"
|
||||
#else
|
||||
#include "math.h"
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef INCLUDE_BIT_ACCESS_LIB
|
||||
#include "bit_access.h"
|
||||
#endif
|
||||
|
||||
#ifdef INCLUDE_TRACKERS_LIB
|
||||
#include "trackers.h"
|
||||
#else
|
||||
#define TrackerTypeDef(num_user_vars) void *
|
||||
#define num_of_usercnts(_user_) 0
|
||||
#define assert_tracecnt(_cntstruct_, _uservarnumb_) 0
|
||||
#define if_assert_usertracker(_cntstruct_, _uservarnumb_) if(0)
|
||||
#define tern_assert_usertracker(_cntstruct_, _uservarnumb_) 0
|
||||
#define TrackerGet_Ok(_cntstruct_) dummy
|
||||
#define TrackerGet_Err(_cntstruct_) dummy
|
||||
#define TrackerGet_Warn(_cntstruct_) dummy
|
||||
#define TrackerGet_User(_cntstruct_, _uservarnumb_) dummy
|
||||
#define TrackerCnt_Ok(_cntstruct_)
|
||||
#define TrackerCnt_Err(_cntstruct_)
|
||||
#define TrackerCnt_Warn(_cntstruct_)
|
||||
#define TrackerCnt_User(_cntstruct_, _uservarnumb_)
|
||||
#define TrackerWrite_User(_cntstruct_, _uservarnumb_, _val_)
|
||||
#define TrackerClear_All(_cntstruct_)
|
||||
#define TrackerClear_Ok(_cntstruct_)
|
||||
#define TrackerClear_Err(_cntstruct_)
|
||||
#define TrackerClear_Warn(_cntstruct_)
|
||||
#define TrackerClear_User(_cntstruct_)
|
||||
#define TrackerClear_UserAll(_cntstruct_)
|
||||
#endif
|
||||
|
||||
#ifdef INCLUDE_TRACE_LIB
|
||||
#include "trace.h"
|
||||
#else
|
||||
#define my_printf(...)
|
||||
#define log_printf(TAG, fmt, ...)
|
||||
#define TRACE_GPIO_SET(_gpio_,_pin_)
|
||||
#define TRACE_GPIO_RESET(_gpio_,_pin_)
|
||||
#define RTT_FlashPrepare(...)
|
||||
#define RTT_EraseFlash(...) 0
|
||||
#define RTT_SaveToFlash(...) 0
|
||||
#define RTT_ReadFromFlash(...) 0
|
||||
#define HF_CheckRecovered(...) 0
|
||||
#define HF_HandleFault(...)
|
||||
#endif
|
||||
|
||||
#ifdef INCLUDE_GEN_OPTIMIZER
|
||||
#include "gen_optimizer.h"
|
||||
#else
|
||||
typedef struct {
|
||||
uint16_t n_params;
|
||||
uint16_t n_cand;
|
||||
uint16_t n_best;
|
||||
uint16_t iq_mutation;
|
||||
int32_t loss[0];
|
||||
int32_t candidates[0][0];
|
||||
} GenOptimizer_t;
|
||||
#define GenOptimizer_Init(opt, n_params, n_cand, n_best, iq_mutation, start_params)
|
||||
#define GenOptimizer_Step(opt, params, LossFunc)
|
||||
#define PARAM_SCALE_Q16(x, min_val, max_val) (x)
|
||||
#define PARAM_UNSCALE_Q16(q16_val, min_val, max_val) (q16_val)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef INCLUDE_BENCH_TIME
|
||||
#include "bench_time.h"
|
||||
#else //BENCH_TIME_ENABLE
|
||||
#define BenchTime_Init()
|
||||
#define BenchTime_Start(channel, ticks, tick_period) 0
|
||||
#define BenchTime_End(channel, ticks) 0
|
||||
#define BenchTime_GetMin(channel) 0
|
||||
#define BenchTime_GetMax(channel) 0
|
||||
#define BenchTime_GetAverage(channel) 0
|
||||
#define BenchTime_GetCount(channel) 0
|
||||
#define BenchTime_GetLast(channel) 0
|
||||
#define BenchTime_ResetStats(channel)
|
||||
#endif //BENCH_TIME_ENABLE
|
||||
|
||||
#ifdef INCLUDE_FILTERS
|
||||
#include "filters.h"
|
||||
#else //INCLUDE_FILTERS
|
||||
#endif //INCLUDE_FILTERS
|
||||
|
||||
#ifdef INCLUDE_GENERAL_PERIPH_LIBS
|
||||
|
||||
#include "__general_flash.h"
|
||||
#include "general_gpio.h"
|
||||
#ifdef HAL_SPI_MODULE_ENABLED
|
||||
#include "general_spi.h"
|
||||
#endif
|
||||
#ifdef HAL_UART_MODULE_ENABLED
|
||||
#include "general_uart.h"
|
||||
#endif
|
||||
#ifdef HAL_TIM_MODULE_ENABLED
|
||||
#include "general_tim.h"
|
||||
#endif
|
||||
|
||||
#endif //INCLUDE_GENERAL_PERIPH_LIBS
|
||||
|
||||
|
||||
|
||||
|
||||
/////////////////////////---USER SETTINGS---/////////////////////////
|
||||
// user includes
|
||||
|
||||
// user settings
|
||||
/////////////////////////---USER SETTINGS---/////////////////////////
|
||||
|
||||
|
||||
#endif // __MYLIBS_INCLUDE_H_
|
||||
393
MDK-ARM/Core/Config/periph_config.h
Normal file
393
MDK-ARM/Core/Config/periph_config.h
Normal file
@@ -0,0 +1,393 @@
|
||||
/*==============================================================================
|
||||
* @file periph_config.h
|
||||
* @author Разваляев Алексей
|
||||
*------------------------------------------------------------------------------
|
||||
* Общий файл конфигурации периферии проекта.
|
||||
*
|
||||
* Содержит:
|
||||
* + Глобальные флаги включения периферии (USE_...)
|
||||
* + Конфигурации тактирования и источников RCU
|
||||
* + Таблицы конфигурации GPIO
|
||||
* + Конфигурационные структуры для периферии:
|
||||
* - GPIO
|
||||
* - UART
|
||||
* - TMR (таймеры)
|
||||
* - ADC (SEQ и DC)
|
||||
* - DMA
|
||||
* - NVIC (приоритеты прерываний)
|
||||
*
|
||||
* Используется драйверами:
|
||||
* - gpio.c
|
||||
* - uart.c
|
||||
* - tmr.c
|
||||
* - adc.c
|
||||
* - dma.c
|
||||
*
|
||||
* Реализация инициализации периферии находится в соответствующих *.c файлах.
|
||||
*==============================================================================
|
||||
*/
|
||||
#pragma once
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "sysclk.h"
|
||||
#include "gpio.h"
|
||||
#include "uart.h"
|
||||
#include "tmr.h"
|
||||
#include "adc.h"
|
||||
|
||||
/* Обработчик ошибок */
|
||||
void Error_Handler(void);
|
||||
|
||||
//-- Общие Конфигурации -------------------------------------------------------
|
||||
// 0 - использовать периферию
|
||||
// 1 - не использовать
|
||||
|
||||
/* UART */
|
||||
#define USE_UART0 0 /*!< Использовать UART0 */
|
||||
#define USE_UART1 1 /*!< Использовать UART1 */
|
||||
|
||||
/* Timers */
|
||||
#define USE_TMR0 1 /*!< Использовать Таймер 0 */
|
||||
#define USE_TMR1 1 /*!< Использовать Таймер 1 */
|
||||
#define USE_TMR2 1 /*!< Использовать Таймер 2 */
|
||||
#define USE_TMR3 0 /*!< Использовать Таймер 3 */
|
||||
|
||||
/* ADC */
|
||||
#define USE_ADC_SEQ0 0 /*!< Использовать Секвенсор 0 */
|
||||
#define USE_ADC_SEQ1 1 /*!< Использовать Секвенсор 1 */
|
||||
#define USE_ADC_DC0 0 /*!< Использовать Компаратор 0 */
|
||||
#define USE_ADC_DC1 0 /*!< Использовать Компаратор 1 */
|
||||
#define USE_ADC_DC2 0 /*!< Использовать Компаратор 2 */
|
||||
#define USE_ADC_DC3 0 /*!< Использовать Компаратор 3 */
|
||||
|
||||
/** @note Для RETARGET надо объявить этот дефайн в проекте
|
||||
Options for Target -> C/C++ -> Defines
|
||||
*/
|
||||
//#define RETARGET // закоментирован - отключен,
|
||||
// // разкоментирован - включен
|
||||
//#define RETARGET_USE_ITM // закоментирован - использовать UART,
|
||||
// // разкоментирован - использовать ITM
|
||||
// Для дальнейшей настройки RETARGET -> retarget_conf.h
|
||||
|
||||
//-- RCU Конфигурации ---------------------------------------------------------
|
||||
/** @brief Источник тактирования МК
|
||||
* @note Система всегда стартует с внутреннего МК и после потом переходит на PLL и заданный здесь источник
|
||||
Поменять тактировние при старте можно в system_K1921VK035.h
|
||||
*/
|
||||
static RCU_PLL_Ref_TypeDef SYSCLK_Oscil_Type = RCU_PLL_Ref_OSEClk;
|
||||
|
||||
/** @brief Желаемая частота тактирования МК в МГц*/
|
||||
#define SYSCLK_CORE_CLOCK_MHZ 100
|
||||
|
||||
/** @brief Частота тиков uwTick тактирования МК */
|
||||
static SYSCLK_TickHz_TypeDef SYSCLK_TickType = SYSCLK_Tick_1ms;
|
||||
|
||||
//-- GPIO Конфигурации --------------------------------------------------------
|
||||
/** @note
|
||||
Note:
|
||||
Периферия сама настроит нужные пины в gpiox_config на альтернативные функции
|
||||
*/
|
||||
|
||||
/** @brief Конфигурации пинов порта GPIOA */
|
||||
static GPIO_Init_TypeDef gpioa_config[] = {
|
||||
// Pin, Mode, OutMode, InMode, PullMode, DriveMode
|
||||
{ GPIO_Pin_0, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_1, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_2, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_3, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_4, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_5, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_6, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_7, GPIO_PinMode_Output, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_8, GPIO_PinMode_Output, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_9, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_10, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_11, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_12, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_13, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_14, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_15, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
};
|
||||
|
||||
/** @brief Конфигурации пинов порта GPIOB */
|
||||
static GPIO_Init_TypeDef gpiob_config[] = {
|
||||
// Pin, Mode, OutMode, InMode, PullMode, DriveMode
|
||||
{ GPIO_Pin_0, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_1, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_2, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_3, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_4, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_5, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_6, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_7, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_8, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_9, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_10, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_11, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_12, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_13, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_14, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
{ GPIO_Pin_15, GPIO_PinMode_Unused, GPIO_OutMode_PP, GPIO_InMode_Schmitt, GPIO_PullMode_Disable, GPIO_DriveMode_HighFast },
|
||||
};
|
||||
|
||||
|
||||
|
||||
//-- UART Конфигурации --------------------------------------------------------
|
||||
#if USE_UART0==1
|
||||
static UART_ExtInit_TypeDef uart0_config = {
|
||||
//StopBit, ParityBit, DataWidth, BaudRate, FIFO, Direction
|
||||
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx,
|
||||
//RxCallback TxCallback IdleCallback ErrCallback
|
||||
NULL, NULL, NULL, NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
#if USE_UART1==1
|
||||
static UART_ExtInit_TypeDef uart1_config = {
|
||||
//StopBit, ParityBit, DataWidth, BaudRate, FIFO, Direction
|
||||
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx,
|
||||
//RxCallback TxCallback IdleCallback ErrCallback
|
||||
NULL, NULL, NULL, NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
//-- TMR Конфигурации ---------------------------------------------------------
|
||||
/** @note Макросы для задания периода:
|
||||
* - LOAD(Period, Prescaler) - период в тиках и прескалер*
|
||||
* - FREQ_HZ(Hz) - период таймера в Герцах
|
||||
* - PERIOD_US(us) - период в микросекундах
|
||||
* * Т.к. аппаратного прескалера нет, используется программный.
|
||||
* Получить тики будто бы они с прескалером можно функциями TMR_Get_Cnt, TMR_Get_Period
|
||||
*/
|
||||
#if USE_TMR0==1
|
||||
static TMR_ExtInit_TypeDef tmr0_config = {
|
||||
//SystemCoreClock, Period Update
|
||||
SYSCLK_CORE_CLOCK_MHZ, LOAD(0xFFFFFFFF, SYSCLK_CORE_CLOCK_MHZ-1),
|
||||
//IT ADCSOC DMAReq ExtInput
|
||||
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
|
||||
};
|
||||
#endif
|
||||
|
||||
#if USE_TMR1==1
|
||||
static TMR_ExtInit_TypeDef tmr1_config = {
|
||||
//SystemCoreClock, Period Update
|
||||
SYSCLK_CORE_CLOCK_MHZ, FREQ_HZ(10),
|
||||
//IT ADCSOC DMAReq ExtInput
|
||||
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
|
||||
};
|
||||
#endif
|
||||
|
||||
#if USE_TMR2==1
|
||||
static TMR_ExtInit_TypeDef tmr2_config = {
|
||||
//SystemCoreClock, Period Update
|
||||
SYSCLK_CORE_CLOCK_MHZ, PERIOD_US(1000000),
|
||||
//IT ADCSOC DMAReq ExtInput
|
||||
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
|
||||
};
|
||||
#endif
|
||||
|
||||
#if USE_TMR3==1
|
||||
static TMR_Init_TypeDef tmr3_config = {
|
||||
//SystemCoreClock, Period Update
|
||||
SYSCLK_CORE_CLOCK_MHZ, PERIOD_US(1000),
|
||||
//IT ADCSOC DMAReq ExtInput
|
||||
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
|
||||
};
|
||||
#endif
|
||||
|
||||
//-- ADC Конфигурации -----------------------------------------------------
|
||||
/** @brief Источник тактирования АЦП */
|
||||
static RCU_PeriphClk_TypeDef ADC_ClockSource = RCU_PeriphClk_PLLClk;
|
||||
/** @brief Желаемая частота тактирования АЦП в МГц*/
|
||||
static float ADC_ClockMHz = 12.5;
|
||||
/** @brief Пины каких каналов инициализировать для АЦП */
|
||||
static ADC_ChannelEnableTypeDef adc_ch_config = {
|
||||
//Channel 0, Channel 1, Channel 2, Channel 3
|
||||
ENABLE, ENABLE, ENABLE, ENABLE,
|
||||
};
|
||||
//-- ADC SEQ Конфигурации -----------------------------------------------------
|
||||
#if USE_ADC_SEQ0==1
|
||||
static ADC_SEQ_ExtInit_TypeDef adc_seq0_config = {
|
||||
//StartEvent, SWStartEn
|
||||
ADC_SEQ_StartEvent_SwReq, ENABLE,
|
||||
//Req[0], Req[1], Req[2], Req[3]
|
||||
ADC_CH_Num_0, ADC_CH_Num_1, ADC_CH_Num_2, ADC_CH_Num_3,
|
||||
//ReqMax, ReqAverage, ReqAverageEn
|
||||
ADC_SEQ_ReqNum_1, ADC_SEQ_Average_2, DISABLE,
|
||||
//RestartCount, RestartAverageEn, RestartTimer (в тиках ADC_ClockMHz)
|
||||
0, DISABLE, 0,
|
||||
//DCEn[0], DCEn[1], DCEn[2], DCEn[3]
|
||||
DISABLE, DISABLE, DISABLE, DISABLE,
|
||||
//DMAFIFOLevel, DMAEn
|
||||
ADC_SEQ_DMAFIFOLevel_1, DISABLE,
|
||||
//IT, ITCount BufferCircular
|
||||
ENABLE, 0, ENABLE,
|
||||
//SEQCpltCallback, BuffHalfCallback, BuffFullCallback, ErrorCallback
|
||||
NULL, NULL, NULL, NULL,
|
||||
};
|
||||
#endif
|
||||
#if USE_ADC_SEQ1==1
|
||||
static ADC_SEQ_ExtInit_TypeDef adc_seq1_config = {
|
||||
//StartEvent, SWStartEn
|
||||
ADC_SEQ_StartEvent_SwReq, ENABLE,
|
||||
//Req[0], Req[1], Req[2], Req[3]
|
||||
ADC_CH_Num_0, ADC_CH_Num_1, ADC_CH_Num_2, ADC_CH_Num_3,
|
||||
//ReqMax, ReqAverage, ReqAverageEn
|
||||
ADC_SEQ_ReqNum_1, ADC_SEQ_Average_2, DISABLE,
|
||||
//RestartCount, RestartAverageEn, RestartTimer (в тиках ADC_ClockMHz)
|
||||
0, DISABLE, 0,
|
||||
//DCEn[0], DCEn[1], DCEn[2], DCEn[3]
|
||||
DISABLE, DISABLE, DISABLE, DISABLE,
|
||||
//DMAFIFOLevel, DMAEn
|
||||
ADC_SEQ_DMAFIFOLevel_1, DISABLE,
|
||||
//IT, ITCount BufferCircular
|
||||
ENABLE, 0, ENABLE,
|
||||
//SEQCpltCallback, BuffHalfCallback, BuffFullCallback, ErrorCallback
|
||||
NULL, NULL, NULL, NULL,
|
||||
};
|
||||
#endif
|
||||
|
||||
//-- ADC DC Конфигурации ------------------------------------------------------
|
||||
#if USE_ADC_DC0==1
|
||||
static ADC_DC_ExtInit_TypeDef adc_dc0_config = {
|
||||
//DCOutput
|
||||
DISABLE,
|
||||
//ThresholdLow, ThresholdHigh
|
||||
0, 0,
|
||||
//Source, Channel, Mode, Condition
|
||||
ADC_DC_Source_EOC, ADC_CH_Num_1, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
|
||||
//IT
|
||||
DISABLE,
|
||||
//DC_TrigCallback, ErrorCallback
|
||||
NULL, NULL
|
||||
};
|
||||
#endif
|
||||
#if USE_ADC_DC1==1
|
||||
static ADC_DC_ExtInit_TypeDef adc_dc1_config = {
|
||||
//DCOutput
|
||||
DISABLE,
|
||||
//ThresholdLow, ThresholdHigh
|
||||
0, 0,
|
||||
//Source, Channel, Mode, Condition
|
||||
ADC_DC_Source_EOC, ADC_CH_Num_1, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
|
||||
//IT
|
||||
DISABLE,
|
||||
//DC_TrigCallback, ErrorCallback
|
||||
NULL, NULL
|
||||
};
|
||||
#endif
|
||||
#if USE_ADC_DC2==1
|
||||
static ADC_DC_ExtInit_TypeDef adc_dc2_config = {
|
||||
//DCOutput
|
||||
DISABLE,
|
||||
//ThresholdLow, ThresholdHigh
|
||||
0, 0,
|
||||
//Source, Channel, Mode, Condition
|
||||
ADC_DC_Source_EOC, ADC_CH_Num_1, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
|
||||
//IT
|
||||
DISABLE,
|
||||
//DC_TrigCallback, ErrorCallback
|
||||
NULL, NULL
|
||||
};
|
||||
#endif
|
||||
#if USE_ADC_DC3==1
|
||||
static ADC_DC_ExtInit_TypeDef adc_dc3_config = {
|
||||
//DCOutput
|
||||
DISABLE,
|
||||
//ThresholdLow, ThresholdHigh
|
||||
0, 0,
|
||||
//Source, Channel, Mode, Condition
|
||||
ADC_DC_Source_EOC, ADC_CH_Num_1, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
|
||||
//IT
|
||||
DISABLE,
|
||||
//DC_TrigCallback, ErrorCallback
|
||||
NULL, NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
//-- NVIC Конфигурации --------------------------------------------------------
|
||||
/** @brief Приоритеты прерываний, 0 - самый высокий приоритет*/
|
||||
static uint8_t NCIV_Priorities[] =
|
||||
{
|
||||
[GPIOA_IRQn] = 0,
|
||||
[GPIOB_IRQn] = 0,
|
||||
[TMR0_IRQn] = 0,
|
||||
[TMR1_IRQn] = 0,
|
||||
[TMR2_IRQn] = 0,
|
||||
[TMR3_IRQn] = 0,
|
||||
[UART0_TD_IRQn] = 0,
|
||||
[UART0_RX_IRQn] = 0,
|
||||
[UART0_TX_IRQn] = 0,
|
||||
[UART0_E_RT_IRQn] = 0,
|
||||
[UART1_TD_IRQn] = 0,
|
||||
[UART1_RX_IRQn] = 0,
|
||||
[UART1_TX_IRQn] = 0,
|
||||
[UART1_E_RT_IRQn] = 0,
|
||||
[SPI_RO_RT_IRQn] = 0,
|
||||
[SPI_RX_IRQn] = 0,
|
||||
[SPI_TX_IRQn] = 0,
|
||||
[I2C_IRQn] = 0,
|
||||
[ECAP0_IRQn] = 0,
|
||||
[ECAP1_IRQn] = 0,
|
||||
[ECAP2_IRQn] = 0,
|
||||
[PWM0_IRQn] = 0,
|
||||
[PWM0_HD_IRQn] = 0,
|
||||
[PWM0_TZ_IRQn] = 0,
|
||||
[PWM1_IRQn] = 0,
|
||||
[PWM1_HD_IRQn] = 0,
|
||||
[PWM1_TZ_IRQn] = 0,
|
||||
[PWM2_IRQn] = 0,
|
||||
[PWM2_HD_IRQn] = 0,
|
||||
[PWM2_TZ_IRQn] = 0,
|
||||
[QEP_IRQn] = 0,
|
||||
[ADC_SEQ0_IRQn] = 0,
|
||||
[ADC_SEQ1_IRQn] = 0,
|
||||
[ADC_DC_IRQn] = 0,
|
||||
[CAN0_IRQn] = 0,
|
||||
[CAN1_IRQn] = 0,
|
||||
[CAN2_IRQn] = 0,
|
||||
[CAN3_IRQn] = 0,
|
||||
[CAN4_IRQn] = 0,
|
||||
[CAN5_IRQn] = 0,
|
||||
[CAN6_IRQn] = 0,
|
||||
[CAN7_IRQn] = 0,
|
||||
[CAN8_IRQn] = 0,
|
||||
[CAN9_IRQn] = 0,
|
||||
[CAN10_IRQn] = 0,
|
||||
[CAN11_IRQn] = 0,
|
||||
[CAN12_IRQn] = 0,
|
||||
[CAN13_IRQn] = 0,
|
||||
[CAN14_IRQn] = 0,
|
||||
[CAN15_IRQn] = 0,
|
||||
[DMA_CH0_IRQn] = 0,
|
||||
[DMA_CH1_IRQn] = 0,
|
||||
[DMA_CH2_IRQn] = 0,
|
||||
[DMA_CH3_IRQn] = 0,
|
||||
[DMA_CH4_IRQn] = 0,
|
||||
[DMA_CH5_IRQn] = 0,
|
||||
[DMA_CH6_IRQn] = 0,
|
||||
[DMA_CH7_IRQn] = 0,
|
||||
[DMA_CH8_IRQn] = 0,
|
||||
[DMA_CH9_IRQn] = 0,
|
||||
[DMA_CH10_IRQn] = 0,
|
||||
[DMA_CH11_IRQn] = 0,
|
||||
[DMA_CH12_IRQn] = 0,
|
||||
[DMA_CH13_IRQn] = 0,
|
||||
[DMA_CH14_IRQn] = 0,
|
||||
[DMA_CH15_IRQn] = 0,
|
||||
[WDT_IRQn] = 0,
|
||||
[RCU_IRQn] = 0,
|
||||
[MFLASH_IRQn] = 0,
|
||||
[FPU_IRQn] = 0,
|
||||
};
|
||||
static inline void NVIC_SetAllPriorities(void)
|
||||
{
|
||||
for(int i = 0; i < sizeof(NCIV_Priorities); i++)
|
||||
{
|
||||
NVIC_SetPriority((IRQn_Type)i, NCIV_Priorities[i]);
|
||||
}
|
||||
}
|
||||
//-- Utils --------------------------------------------------------------------
|
||||
|
||||
|
||||
1
MDK-ARM/Core/ExtendedLibs
Submodule
1
MDK-ARM/Core/ExtendedLibs
Submodule
Submodule MDK-ARM/Core/ExtendedLibs added at 795ebbd220
794
MDK-ARM/Template.uvoptx
Normal file
794
MDK-ARM/Template.uvoptx
Normal file
@@ -0,0 +1,794 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
|
||||
<ProjectOpt xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_optx.xsd">
|
||||
|
||||
<SchemaVersion>1.0</SchemaVersion>
|
||||
|
||||
<Header>### uVision Project, (C) Keil Software</Header>
|
||||
|
||||
<Extensions>
|
||||
<cExt>*.c</cExt>
|
||||
<aExt>*.s*; *.src; *.a*</aExt>
|
||||
<oExt>*.obj; *.o</oExt>
|
||||
<lExt>*.lib</lExt>
|
||||
<tExt>*.txt; *.h; *.inc; *.md</tExt>
|
||||
<pExt>*.plm</pExt>
|
||||
<CppX>*.cpp; *.cc; *.cxx</CppX>
|
||||
<nMigrate>0</nMigrate>
|
||||
</Extensions>
|
||||
|
||||
<DaveTm>
|
||||
<dwLowDateTime>0</dwLowDateTime>
|
||||
<dwHighDateTime>0</dwHighDateTime>
|
||||
</DaveTm>
|
||||
|
||||
<Target>
|
||||
<TargetName>template</TargetName>
|
||||
<ToolsetNumber>0x4</ToolsetNumber>
|
||||
<ToolsetName>ARM-ADS</ToolsetName>
|
||||
<TargetOption>
|
||||
<CLKADS>12000000</CLKADS>
|
||||
<OPTTT>
|
||||
<gFlags>1</gFlags>
|
||||
<BeepAtEnd>1</BeepAtEnd>
|
||||
<RunSim>0</RunSim>
|
||||
<RunTarget>1</RunTarget>
|
||||
<RunAbUc>0</RunAbUc>
|
||||
</OPTTT>
|
||||
<OPTHX>
|
||||
<HexSelection>1</HexSelection>
|
||||
<FlashByte>65535</FlashByte>
|
||||
<HexRangeLowAddress>0</HexRangeLowAddress>
|
||||
<HexRangeHighAddress>0</HexRangeHighAddress>
|
||||
<HexOffset>0</HexOffset>
|
||||
</OPTHX>
|
||||
<OPTLEX>
|
||||
<PageWidth>79</PageWidth>
|
||||
<PageLength>66</PageLength>
|
||||
<TabStop>8</TabStop>
|
||||
<ListingPath>.\Listings\</ListingPath>
|
||||
</OPTLEX>
|
||||
<ListingPage>
|
||||
<CreateCListing>1</CreateCListing>
|
||||
<CreateAListing>1</CreateAListing>
|
||||
<CreateLListing>1</CreateLListing>
|
||||
<CreateIListing>0</CreateIListing>
|
||||
<AsmCond>1</AsmCond>
|
||||
<AsmSymb>1</AsmSymb>
|
||||
<AsmXref>0</AsmXref>
|
||||
<CCond>1</CCond>
|
||||
<CCode>0</CCode>
|
||||
<CListInc>0</CListInc>
|
||||
<CSymb>0</CSymb>
|
||||
<LinkerCodeListing>0</LinkerCodeListing>
|
||||
</ListingPage>
|
||||
<OPTXL>
|
||||
<LMap>1</LMap>
|
||||
<LComments>1</LComments>
|
||||
<LGenerateSymbols>1</LGenerateSymbols>
|
||||
<LLibSym>1</LLibSym>
|
||||
<LLines>1</LLines>
|
||||
<LLocSym>1</LLocSym>
|
||||
<LPubSym>1</LPubSym>
|
||||
<LXref>0</LXref>
|
||||
<LExpSel>0</LExpSel>
|
||||
</OPTXL>
|
||||
<OPTFL>
|
||||
<tvExp>1</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<IsCurrentTarget>1</IsCurrentTarget>
|
||||
</OPTFL>
|
||||
<CpuCode>255</CpuCode>
|
||||
<DebugOpt>
|
||||
<uSim>0</uSim>
|
||||
<uTrg>1</uTrg>
|
||||
<sLdApp>1</sLdApp>
|
||||
<sGomain>1</sGomain>
|
||||
<sRbreak>1</sRbreak>
|
||||
<sRwatch>1</sRwatch>
|
||||
<sRmem>1</sRmem>
|
||||
<sRfunc>1</sRfunc>
|
||||
<sRbox>1</sRbox>
|
||||
<tLdApp>1</tLdApp>
|
||||
<tGomain>1</tGomain>
|
||||
<tRbreak>1</tRbreak>
|
||||
<tRwatch>1</tRwatch>
|
||||
<tRmem>1</tRmem>
|
||||
<tRfunc>0</tRfunc>
|
||||
<tRbox>1</tRbox>
|
||||
<tRtrace>1</tRtrace>
|
||||
<sRSysVw>1</sRSysVw>
|
||||
<tRSysVw>1</tRSysVw>
|
||||
<sRunDeb>0</sRunDeb>
|
||||
<sLrtime>0</sLrtime>
|
||||
<bEvRecOn>1</bEvRecOn>
|
||||
<bSchkAxf>0</bSchkAxf>
|
||||
<bTchkAxf>0</bTchkAxf>
|
||||
<nTsel>4</nTsel>
|
||||
<sDll></sDll>
|
||||
<sDllPa></sDllPa>
|
||||
<sDlgDll></sDlgDll>
|
||||
<sDlgPa></sDlgPa>
|
||||
<sIfile></sIfile>
|
||||
<tDll></tDll>
|
||||
<tDllPa></tDllPa>
|
||||
<tDlgDll></tDlgDll>
|
||||
<tDlgPa></tDlgPa>
|
||||
<tIfile></tIfile>
|
||||
<pMon>Segger\JL2CM3.dll</pMon>
|
||||
</DebugOpt>
|
||||
<TargetDriverDllRegistry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>ARMRTXEVENTFLAGS</Key>
|
||||
<Name>-L70 -Z18 -C0 -M0 -T1</Name>
|
||||
</SetRegEntry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>DLGTARM</Key>
|
||||
<Name>(1010=-1,-1,-1,-1,0)(1007=-1,-1,-1,-1,0)(1008=-1,-1,-1,-1,0)(1009=-1,-1,-1,-1,0)(1012=-1,-1,-1,-1,0)</Name>
|
||||
</SetRegEntry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>ARMDBGFLAGS</Key>
|
||||
<Name></Name>
|
||||
</SetRegEntry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>JL2CM3</Key>
|
||||
<Name>-U-O14 -O14 -S2 -ZTIFSpeedSel5000 -A0 -C0 -JU1 -JI127.0.0.1 -JP0 -RST0 -N00("ARM CoreSight JTAG-DP") -D00(4BA00477) -L00(4) -TO18 -TC10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -TB1 -TFE0 -FO7 -FD20000000 -FC1000 -FN1 -FF0K1921VK035.FLM -FS00 -FL010000 -FP0($$Device:K1921VK035$Flash\K1921VK035.FLM)</Name>
|
||||
</SetRegEntry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>DLGUARM</Key>
|
||||
<Name></Name>
|
||||
</SetRegEntry>
|
||||
<SetRegEntry>
|
||||
<Number>0</Number>
|
||||
<Key>UL2CM3</Key>
|
||||
<Name>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC1000 -FN1 -FF0K1921VK035 -FS00 -FL010000 -FP0($$Device:K1921VK035$Flash\K1921VK035.FLM))</Name>
|
||||
</SetRegEntry>
|
||||
</TargetDriverDllRegistry>
|
||||
<Breakpoint/>
|
||||
<WatchWindow1>
|
||||
<Ww>
|
||||
<count>0</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>msTick,0x0A</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>1</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>huart1</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>2</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>hadc</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>3</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>tickbuff</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>4</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>adc_seq1_config</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>5</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>ch3_config</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>6</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>starttick - htmr->Instance->VALUE,0x0A</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>7</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>gpiob_config</ItemText>
|
||||
</Ww>
|
||||
<Ww>
|
||||
<count>8</count>
|
||||
<WinNumber>1</WinNumber>
|
||||
<ItemText>seq0_buff</ItemText>
|
||||
</Ww>
|
||||
</WatchWindow1>
|
||||
<Tracepoint>
|
||||
<THDelay>0</THDelay>
|
||||
</Tracepoint>
|
||||
<DebugFlag>
|
||||
<trace>0</trace>
|
||||
<periodic>1</periodic>
|
||||
<aLwin>1</aLwin>
|
||||
<aCover>0</aCover>
|
||||
<aSer1>0</aSer1>
|
||||
<aSer2>0</aSer2>
|
||||
<aPa>0</aPa>
|
||||
<viewmode>1</viewmode>
|
||||
<vrSel>0</vrSel>
|
||||
<aSym>0</aSym>
|
||||
<aTbox>0</aTbox>
|
||||
<AscS1>0</AscS1>
|
||||
<AscS2>0</AscS2>
|
||||
<AscS3>0</AscS3>
|
||||
<aSer3>0</aSer3>
|
||||
<eProf>0</eProf>
|
||||
<aLa>0</aLa>
|
||||
<aPa1>0</aPa1>
|
||||
<AscS4>0</AscS4>
|
||||
<aSer4>0</aSer4>
|
||||
<StkLoc>0</StkLoc>
|
||||
<TrcWin>0</TrcWin>
|
||||
<newCpu>0</newCpu>
|
||||
<uProt>0</uProt>
|
||||
</DebugFlag>
|
||||
<LintExecutable></LintExecutable>
|
||||
<LintConfigFile></LintConfigFile>
|
||||
<bLintAuto>0</bLintAuto>
|
||||
<bAutoGenD>0</bAutoGenD>
|
||||
<LntExFlags>0</LntExFlags>
|
||||
<pMisraName></pMisraName>
|
||||
<pszMrule></pszMrule>
|
||||
<pSingCmds></pSingCmds>
|
||||
<pMultCmds></pMultCmds>
|
||||
<pMisraNamep></pMisraNamep>
|
||||
<pszMrulep></pszMrulep>
|
||||
<pSingCmdsp></pSingCmdsp>
|
||||
<pMultCmdsp></pMultCmdsp>
|
||||
<SystemViewers>
|
||||
<Entry>
|
||||
<Name>System Viewer\ADC</Name>
|
||||
<WinId>35905</WinId>
|
||||
</Entry>
|
||||
<Entry>
|
||||
<Name>System Viewer\GPIOB</Name>
|
||||
<WinId>35904</WinId>
|
||||
</Entry>
|
||||
</SystemViewers>
|
||||
</TargetOption>
|
||||
</Target>
|
||||
|
||||
<Group>
|
||||
<GroupName>Config</GroupName>
|
||||
<tvExp>1</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>1</GroupNumber>
|
||||
<FileNumber>1</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\Config\mylibs_config.h</PathWithFileName>
|
||||
<FilenameWithoutPath>mylibs_config.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>1</GroupNumber>
|
||||
<FileNumber>2</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\Config\mylibs_include.h</PathWithFileName>
|
||||
<FilenameWithoutPath>mylibs_include.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>1</GroupNumber>
|
||||
<FileNumber>3</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\Config\SEGGER_RTT_Conf.h</PathWithFileName>
|
||||
<FilenameWithoutPath>SEGGER_RTT_Conf.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>1</GroupNumber>
|
||||
<FileNumber>4</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\Config\periph_config.h</PathWithFileName>
|
||||
<FilenameWithoutPath>periph_config.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
<Group>
|
||||
<GroupName>App</GroupName>
|
||||
<tvExp>1</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>5</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\main.c</PathWithFileName>
|
||||
<FilenameWithoutPath>main.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>6</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\gpio.c</PathWithFileName>
|
||||
<FilenameWithoutPath>gpio.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>7</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\tmr.c</PathWithFileName>
|
||||
<FilenameWithoutPath>tmr.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>8</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\uart.c</PathWithFileName>
|
||||
<FilenameWithoutPath>uart.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>9</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\adc.c</PathWithFileName>
|
||||
<FilenameWithoutPath>adc.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>10</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\sysclk.c</PathWithFileName>
|
||||
<FilenameWithoutPath>sysclk.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>2</GroupNumber>
|
||||
<FileNumber>11</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\App\vk035_it.c</PathWithFileName>
|
||||
<FilenameWithoutPath>vk035_it.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
<Group>
|
||||
<GroupName>MyLibs</GroupName>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>12</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\bench_time.h</PathWithFileName>
|
||||
<FilenameWithoutPath>bench_time.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>13</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\bit_access.h</PathWithFileName>
|
||||
<FilenameWithoutPath>bit_access.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>14</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\gen_optimizer.h</PathWithFileName>
|
||||
<FilenameWithoutPath>gen_optimizer.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>15</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\mylibs_defs.h</PathWithFileName>
|
||||
<FilenameWithoutPath>mylibs_defs.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>16</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\trace.h</PathWithFileName>
|
||||
<FilenameWithoutPath>trace.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>17</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\trackers.h</PathWithFileName>
|
||||
<FilenameWithoutPath>trackers.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>18</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\RTT\SEGGER_RTT.c</PathWithFileName>
|
||||
<FilenameWithoutPath>SEGGER_RTT.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>19</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\RTT\SEGGER_RTT_printf.c</PathWithFileName>
|
||||
<FilenameWithoutPath>SEGGER_RTT_printf.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>20</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Inc\filters.h</PathWithFileName>
|
||||
<FilenameWithoutPath>filters.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>3</GroupNumber>
|
||||
<FileNumber>21</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\Core\ExtendedLibs\MyLibs\Src\filters.c</PathWithFileName>
|
||||
<FilenameWithoutPath>filters.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
<Group>
|
||||
<GroupName>startup</GroupName>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>4</GroupNumber>
|
||||
<FileNumber>22</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\Device\NIIET\K1921VK035\Source\system_K1921VK035.c</PathWithFileName>
|
||||
<FilenameWithoutPath>system_K1921VK035.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>4</GroupNumber>
|
||||
<FileNumber>23</FileNumber>
|
||||
<FileType>2</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\Device\NIIET\K1921VK035\Source\ARM\startup_K1921VK035.s</PathWithFileName>
|
||||
<FilenameWithoutPath>startup_K1921VK035.s</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
<Group>
|
||||
<GroupName>plib035</GroupName>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>24</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_adc.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_adc.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>25</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_can.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_can.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>26</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_dma.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_dma.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>27</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_ecap.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_ecap.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>28</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_gpio.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_gpio.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>29</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_i2c.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_i2c.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>30</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_mflash.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_mflash.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>31</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_pmu.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_pmu.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>32</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_pwm.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_pwm.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>33</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_qep.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_qep.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>34</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_rcu.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_rcu.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>35</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_spi.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_spi.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>36</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_tmr.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_tmr.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>37</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_uart.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_uart.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>5</GroupNumber>
|
||||
<FileNumber>38</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\plib035\src\plib035_wdt.c</PathWithFileName>
|
||||
<FilenameWithoutPath>plib035_wdt.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
<Group>
|
||||
<GroupName>Retarget</GroupName>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<cbSel>0</cbSel>
|
||||
<RteFlg>0</RteFlg>
|
||||
<File>
|
||||
<GroupNumber>6</GroupNumber>
|
||||
<FileNumber>39</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\retarget\retarget.c</PathWithFileName>
|
||||
<FilenameWithoutPath>retarget.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>6</GroupNumber>
|
||||
<FileNumber>40</FileNumber>
|
||||
<FileType>1</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\retarget\retarget_conf.c</PathWithFileName>
|
||||
<FilenameWithoutPath>retarget_conf.c</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
<File>
|
||||
<GroupNumber>6</GroupNumber>
|
||||
<FileNumber>41</FileNumber>
|
||||
<FileType>5</FileType>
|
||||
<tvExp>0</tvExp>
|
||||
<tvExpOptDlg>0</tvExpOptDlg>
|
||||
<bDave2>0</bDave2>
|
||||
<PathWithFileName>.\platform\retarget\retarget_conf.h</PathWithFileName>
|
||||
<FilenameWithoutPath>retarget_conf.h</FilenameWithoutPath>
|
||||
<RteFlg>0</RteFlg>
|
||||
<bShared>0</bShared>
|
||||
</File>
|
||||
</Group>
|
||||
|
||||
</ProjectOpt>
|
||||
639
MDK-ARM/Template.uvprojx
Normal file
639
MDK-ARM/Template.uvprojx
Normal file
@@ -0,0 +1,639 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
|
||||
<Project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_projx.xsd">
|
||||
|
||||
<SchemaVersion>2.1</SchemaVersion>
|
||||
|
||||
<Header>### uVision Project, (C) Keil Software</Header>
|
||||
|
||||
<Targets>
|
||||
<Target>
|
||||
<TargetName>template</TargetName>
|
||||
<ToolsetNumber>0x4</ToolsetNumber>
|
||||
<ToolsetName>ARM-ADS</ToolsetName>
|
||||
<pCCUsed>5060960::V5.06 update 7 (build 960)::.\ARMCC</pCCUsed>
|
||||
<uAC6>0</uAC6>
|
||||
<TargetOption>
|
||||
<TargetCommonOption>
|
||||
<Device>K1921VK035</Device>
|
||||
<Vendor>Generic</Vendor>
|
||||
<PackID>NIIET.K1921VK035_DFP.2.0.6</PackID>
|
||||
<PackURL>http://www.keil.com/pack/</PackURL>
|
||||
<Cpu>IRAM(0x20000000,0x4000) IROM(0x00000000,0x10000) CPUTYPE("Cortex-M4") FPU2 CLOCK(12000000) ELITTLE</Cpu>
|
||||
<FlashUtilSpec></FlashUtilSpec>
|
||||
<StartupFile></StartupFile>
|
||||
<FlashDriverDll>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC3000 -FN2 -FF0K1921VK035 -FS00 -FL010000 -FF1K1921VK035_SRV -FS10 -FL1100000 -FP0($$Device:K1921VK035$Flash\K1921VK035.FLM) -FP1($$Device:K1921VK035$Flash\K1921VK035_SRV.FLM))</FlashDriverDll>
|
||||
<DeviceId>0</DeviceId>
|
||||
<RegisterFile>$$Device:K1921VK035$Device\Include\K1921VK035.h</RegisterFile>
|
||||
<MemoryEnv></MemoryEnv>
|
||||
<Cmp></Cmp>
|
||||
<Asm></Asm>
|
||||
<Linker></Linker>
|
||||
<OHString></OHString>
|
||||
<InfinionOptionDll></InfinionOptionDll>
|
||||
<SLE66CMisc></SLE66CMisc>
|
||||
<SLE66AMisc></SLE66AMisc>
|
||||
<SLE66LinkerMisc></SLE66LinkerMisc>
|
||||
<SFDFile>$$Device:K1921VK035$SVD\K1921VK035.svd</SFDFile>
|
||||
<bCustSvd>0</bCustSvd>
|
||||
<UseEnv>0</UseEnv>
|
||||
<BinPath></BinPath>
|
||||
<IncludePath></IncludePath>
|
||||
<LibPath></LibPath>
|
||||
<RegisterFilePath></RegisterFilePath>
|
||||
<DBRegisterFilePath></DBRegisterFilePath>
|
||||
<TargetStatus>
|
||||
<Error>0</Error>
|
||||
<ExitCodeStop>0</ExitCodeStop>
|
||||
<ButtonStop>0</ButtonStop>
|
||||
<NotGenerated>0</NotGenerated>
|
||||
<InvalidFlash>1</InvalidFlash>
|
||||
</TargetStatus>
|
||||
<OutputDirectory>.\Objects\</OutputDirectory>
|
||||
<OutputName>Firmware</OutputName>
|
||||
<CreateExecutable>1</CreateExecutable>
|
||||
<CreateLib>0</CreateLib>
|
||||
<CreateHexFile>0</CreateHexFile>
|
||||
<DebugInformation>1</DebugInformation>
|
||||
<BrowseInformation>1</BrowseInformation>
|
||||
<ListingPath>.\Listings\</ListingPath>
|
||||
<HexFormatSelection>1</HexFormatSelection>
|
||||
<Merge32K>0</Merge32K>
|
||||
<CreateBatchFile>0</CreateBatchFile>
|
||||
<BeforeCompile>
|
||||
<RunUserProg1>0</RunUserProg1>
|
||||
<RunUserProg2>0</RunUserProg2>
|
||||
<UserProg1Name></UserProg1Name>
|
||||
<UserProg2Name></UserProg2Name>
|
||||
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
|
||||
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
|
||||
<nStopU1X>0</nStopU1X>
|
||||
<nStopU2X>0</nStopU2X>
|
||||
</BeforeCompile>
|
||||
<BeforeMake>
|
||||
<RunUserProg1>0</RunUserProg1>
|
||||
<RunUserProg2>0</RunUserProg2>
|
||||
<UserProg1Name></UserProg1Name>
|
||||
<UserProg2Name></UserProg2Name>
|
||||
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
|
||||
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
|
||||
<nStopB1X>0</nStopB1X>
|
||||
<nStopB2X>0</nStopB2X>
|
||||
</BeforeMake>
|
||||
<AfterMake>
|
||||
<RunUserProg1>1</RunUserProg1>
|
||||
<RunUserProg2>0</RunUserProg2>
|
||||
<UserProg1Name>fromelf.exe --bin --output .\Listings\@L.bin !L</UserProg1Name>
|
||||
<UserProg2Name></UserProg2Name>
|
||||
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
|
||||
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
|
||||
<nStopA1X>0</nStopA1X>
|
||||
<nStopA2X>0</nStopA2X>
|
||||
</AfterMake>
|
||||
<SelectedForBatchBuild>0</SelectedForBatchBuild>
|
||||
<SVCSIdString></SVCSIdString>
|
||||
</TargetCommonOption>
|
||||
<CommonProperty>
|
||||
<UseCPPCompiler>0</UseCPPCompiler>
|
||||
<RVCTCodeConst>0</RVCTCodeConst>
|
||||
<RVCTZI>0</RVCTZI>
|
||||
<RVCTOtherData>0</RVCTOtherData>
|
||||
<ModuleSelection>0</ModuleSelection>
|
||||
<IncludeInBuild>1</IncludeInBuild>
|
||||
<AlwaysBuild>0</AlwaysBuild>
|
||||
<GenerateAssemblyFile>0</GenerateAssemblyFile>
|
||||
<AssembleAssemblyFile>0</AssembleAssemblyFile>
|
||||
<PublicsOnly>0</PublicsOnly>
|
||||
<StopOnExitCode>3</StopOnExitCode>
|
||||
<CustomArgument></CustomArgument>
|
||||
<IncludeLibraryModules></IncludeLibraryModules>
|
||||
<ComprImg>1</ComprImg>
|
||||
</CommonProperty>
|
||||
<DllOption>
|
||||
<SimDllName>SARMCM3.DLL</SimDllName>
|
||||
<SimDllArguments> -MPU</SimDllArguments>
|
||||
<SimDlgDll>DCM.DLL</SimDlgDll>
|
||||
<SimDlgDllArguments>-pCM4</SimDlgDllArguments>
|
||||
<TargetDllName>SARMCM3.DLL</TargetDllName>
|
||||
<TargetDllArguments> -MPU</TargetDllArguments>
|
||||
<TargetDlgDll>TCM.DLL</TargetDlgDll>
|
||||
<TargetDlgDllArguments>-pCM4</TargetDlgDllArguments>
|
||||
</DllOption>
|
||||
<DebugOption>
|
||||
<OPTHX>
|
||||
<HexSelection>1</HexSelection>
|
||||
<HexRangeLowAddress>0</HexRangeLowAddress>
|
||||
<HexRangeHighAddress>0</HexRangeHighAddress>
|
||||
<HexOffset>0</HexOffset>
|
||||
<Oh166RecLen>16</Oh166RecLen>
|
||||
</OPTHX>
|
||||
</DebugOption>
|
||||
<Utilities>
|
||||
<Flash1>
|
||||
<UseTargetDll>1</UseTargetDll>
|
||||
<UseExternalTool>0</UseExternalTool>
|
||||
<RunIndependent>0</RunIndependent>
|
||||
<UpdateFlashBeforeDebugging>1</UpdateFlashBeforeDebugging>
|
||||
<Capability>1</Capability>
|
||||
<DriverSelection>4096</DriverSelection>
|
||||
</Flash1>
|
||||
<bUseTDR>1</bUseTDR>
|
||||
<Flash2>BIN\UL2CM3.DLL</Flash2>
|
||||
<Flash3>"" ()</Flash3>
|
||||
<Flash4></Flash4>
|
||||
<pFcarmOut></pFcarmOut>
|
||||
<pFcarmGrp></pFcarmGrp>
|
||||
<pFcArmRoot></pFcArmRoot>
|
||||
<FcArmLst>0</FcArmLst>
|
||||
</Utilities>
|
||||
<TargetArmAds>
|
||||
<ArmAdsMisc>
|
||||
<GenerateListings>0</GenerateListings>
|
||||
<asHll>1</asHll>
|
||||
<asAsm>1</asAsm>
|
||||
<asMacX>1</asMacX>
|
||||
<asSyms>1</asSyms>
|
||||
<asFals>1</asFals>
|
||||
<asDbgD>1</asDbgD>
|
||||
<asForm>1</asForm>
|
||||
<ldLst>0</ldLst>
|
||||
<ldmm>1</ldmm>
|
||||
<ldXref>1</ldXref>
|
||||
<BigEnd>0</BigEnd>
|
||||
<AdsALst>1</AdsALst>
|
||||
<AdsACrf>1</AdsACrf>
|
||||
<AdsANop>0</AdsANop>
|
||||
<AdsANot>0</AdsANot>
|
||||
<AdsLLst>1</AdsLLst>
|
||||
<AdsLmap>1</AdsLmap>
|
||||
<AdsLcgr>1</AdsLcgr>
|
||||
<AdsLsym>1</AdsLsym>
|
||||
<AdsLszi>1</AdsLszi>
|
||||
<AdsLtoi>1</AdsLtoi>
|
||||
<AdsLsun>1</AdsLsun>
|
||||
<AdsLven>1</AdsLven>
|
||||
<AdsLsxf>1</AdsLsxf>
|
||||
<RvctClst>0</RvctClst>
|
||||
<GenPPlst>0</GenPPlst>
|
||||
<AdsCpuType>"Cortex-M4"</AdsCpuType>
|
||||
<RvctDeviceName></RvctDeviceName>
|
||||
<mOS>0</mOS>
|
||||
<uocRom>0</uocRom>
|
||||
<uocRam>0</uocRam>
|
||||
<hadIROM>1</hadIROM>
|
||||
<hadIRAM>1</hadIRAM>
|
||||
<hadXRAM>0</hadXRAM>
|
||||
<uocXRam>0</uocXRam>
|
||||
<RvdsVP>2</RvdsVP>
|
||||
<RvdsMve>0</RvdsMve>
|
||||
<RvdsCdeCp>0</RvdsCdeCp>
|
||||
<nBranchProt>0</nBranchProt>
|
||||
<hadIRAM2>0</hadIRAM2>
|
||||
<hadIROM2>0</hadIROM2>
|
||||
<StupSel>8</StupSel>
|
||||
<useUlib>0</useUlib>
|
||||
<EndSel>0</EndSel>
|
||||
<uLtcg>0</uLtcg>
|
||||
<nSecure>0</nSecure>
|
||||
<RoSelD>3</RoSelD>
|
||||
<RwSelD>3</RwSelD>
|
||||
<CodeSel>0</CodeSel>
|
||||
<OptFeed>0</OptFeed>
|
||||
<NoZi1>0</NoZi1>
|
||||
<NoZi2>0</NoZi2>
|
||||
<NoZi3>0</NoZi3>
|
||||
<NoZi4>0</NoZi4>
|
||||
<NoZi5>0</NoZi5>
|
||||
<Ro1Chk>0</Ro1Chk>
|
||||
<Ro2Chk>0</Ro2Chk>
|
||||
<Ro3Chk>0</Ro3Chk>
|
||||
<Ir1Chk>1</Ir1Chk>
|
||||
<Ir2Chk>0</Ir2Chk>
|
||||
<Ra1Chk>0</Ra1Chk>
|
||||
<Ra2Chk>0</Ra2Chk>
|
||||
<Ra3Chk>0</Ra3Chk>
|
||||
<Im1Chk>1</Im1Chk>
|
||||
<Im2Chk>0</Im2Chk>
|
||||
<OnChipMemories>
|
||||
<Ocm1>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm1>
|
||||
<Ocm2>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm2>
|
||||
<Ocm3>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm3>
|
||||
<Ocm4>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm4>
|
||||
<Ocm5>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm5>
|
||||
<Ocm6>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</Ocm6>
|
||||
<IRAM>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x20000000</StartAddress>
|
||||
<Size>0x4000</Size>
|
||||
</IRAM>
|
||||
<IROM>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x10000</Size>
|
||||
</IROM>
|
||||
<XRAM>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</XRAM>
|
||||
<OCR_RVCT1>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT1>
|
||||
<OCR_RVCT2>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT2>
|
||||
<OCR_RVCT3>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT3>
|
||||
<OCR_RVCT4>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x10000</Size>
|
||||
</OCR_RVCT4>
|
||||
<OCR_RVCT5>
|
||||
<Type>1</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT5>
|
||||
<OCR_RVCT6>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT6>
|
||||
<OCR_RVCT7>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT7>
|
||||
<OCR_RVCT8>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT8>
|
||||
<OCR_RVCT9>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x20000000</StartAddress>
|
||||
<Size>0x4000</Size>
|
||||
</OCR_RVCT9>
|
||||
<OCR_RVCT10>
|
||||
<Type>0</Type>
|
||||
<StartAddress>0x0</StartAddress>
|
||||
<Size>0x0</Size>
|
||||
</OCR_RVCT10>
|
||||
</OnChipMemories>
|
||||
<RvctStartVector></RvctStartVector>
|
||||
</ArmAdsMisc>
|
||||
<Cads>
|
||||
<interw>1</interw>
|
||||
<Optim>2</Optim>
|
||||
<oTime>0</oTime>
|
||||
<SplitLS>0</SplitLS>
|
||||
<OneElfS>1</OneElfS>
|
||||
<Strict>0</Strict>
|
||||
<EnumInt>0</EnumInt>
|
||||
<PlainCh>0</PlainCh>
|
||||
<Ropi>0</Ropi>
|
||||
<Rwpi>0</Rwpi>
|
||||
<wLevel>2</wLevel>
|
||||
<uThumb>0</uThumb>
|
||||
<uSurpInc>0</uSurpInc>
|
||||
<uC99>1</uC99>
|
||||
<uGnu>0</uGnu>
|
||||
<useXO>0</useXO>
|
||||
<v6Lang>3</v6Lang>
|
||||
<v6LangP>5</v6LangP>
|
||||
<vShortEn>1</vShortEn>
|
||||
<vShortWch>1</vShortWch>
|
||||
<v6Lto>0</v6Lto>
|
||||
<v6WtE>0</v6WtE>
|
||||
<v6Rtti>0</v6Rtti>
|
||||
<VariousControls>
|
||||
<MiscControls></MiscControls>
|
||||
<Define></Define>
|
||||
<Undefine></Undefine>
|
||||
<IncludePath>.\platform\CMSIS\Core\Include;.\platform\Device\NIIET\K1921VK035\Include;.\platform\plib035\inc;.\platform\retarget;.\platform\retarget\Template\K1921VK035;.\Core\App;.\Core\Config;.\Core\ExtendedLibs;.\Core\ExtendedLibs\MyLibs\Inc;.\Core\ExtendedLibs\RTT</IncludePath>
|
||||
</VariousControls>
|
||||
</Cads>
|
||||
<Aads>
|
||||
<interw>1</interw>
|
||||
<Ropi>0</Ropi>
|
||||
<Rwpi>0</Rwpi>
|
||||
<thumb>0</thumb>
|
||||
<SplitLS>0</SplitLS>
|
||||
<SwStkChk>0</SwStkChk>
|
||||
<NoWarn>0</NoWarn>
|
||||
<uSurpInc>0</uSurpInc>
|
||||
<useXO>0</useXO>
|
||||
<ClangAsOpt>4</ClangAsOpt>
|
||||
<VariousControls>
|
||||
<MiscControls></MiscControls>
|
||||
<Define></Define>
|
||||
<Undefine></Undefine>
|
||||
<IncludePath></IncludePath>
|
||||
</VariousControls>
|
||||
</Aads>
|
||||
<LDads>
|
||||
<umfTarg>0</umfTarg>
|
||||
<Ropi>0</Ropi>
|
||||
<Rwpi>0</Rwpi>
|
||||
<noStLib>0</noStLib>
|
||||
<RepFail>1</RepFail>
|
||||
<useFile>0</useFile>
|
||||
<TextAddressRange>0x00000000</TextAddressRange>
|
||||
<DataAddressRange>0x20000000</DataAddressRange>
|
||||
<pXoBase></pXoBase>
|
||||
<ScatterFile></ScatterFile>
|
||||
<IncludeLibs></IncludeLibs>
|
||||
<IncludeLibsPath></IncludeLibsPath>
|
||||
<Misc></Misc>
|
||||
<LinkerInputFile></LinkerInputFile>
|
||||
<DisabledWarnings></DisabledWarnings>
|
||||
</LDads>
|
||||
</TargetArmAds>
|
||||
</TargetOption>
|
||||
<Groups>
|
||||
<Group>
|
||||
<GroupName>Config</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>mylibs_config.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\Config\mylibs_config.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>mylibs_include.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\Config\mylibs_include.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>SEGGER_RTT_Conf.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\Config\SEGGER_RTT_Conf.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>periph_config.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\Config\periph_config.h</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
<GroupName>App</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>main.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\main.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>gpio.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\gpio.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>tmr.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\tmr.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>uart.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\uart.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>adc.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\adc.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>sysclk.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\sysclk.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>vk035_it.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\App\vk035_it.c</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
<GroupName>MyLibs</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>bench_time.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\bench_time.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>bit_access.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\bit_access.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>gen_optimizer.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\gen_optimizer.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>mylibs_defs.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\mylibs_defs.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>trace.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\trace.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>trackers.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\trackers.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>SEGGER_RTT.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\RTT\SEGGER_RTT.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>SEGGER_RTT_printf.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\RTT\SEGGER_RTT_printf.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>filters.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Inc\filters.h</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>filters.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\Core\ExtendedLibs\MyLibs\Src\filters.c</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
<GroupName>startup</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>system_K1921VK035.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\Device\NIIET\K1921VK035\Source\system_K1921VK035.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>startup_K1921VK035.s</FileName>
|
||||
<FileType>2</FileType>
|
||||
<FilePath>.\platform\Device\NIIET\K1921VK035\Source\ARM\startup_K1921VK035.s</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
<GroupName>plib035</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>plib035_adc.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_adc.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_can.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_can.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_dma.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_dma.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_ecap.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_ecap.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_gpio.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_gpio.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_i2c.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_i2c.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_mflash.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_mflash.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_pmu.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_pmu.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_pwm.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_pwm.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_qep.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_qep.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_rcu.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_rcu.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_spi.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_spi.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_tmr.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_tmr.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_uart.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_uart.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>plib035_wdt.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\plib035\src\plib035_wdt.c</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
<Group>
|
||||
<GroupName>Retarget</GroupName>
|
||||
<Files>
|
||||
<File>
|
||||
<FileName>retarget.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\retarget\retarget.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>retarget_conf.c</FileName>
|
||||
<FileType>1</FileType>
|
||||
<FilePath>.\platform\retarget\retarget_conf.c</FilePath>
|
||||
</File>
|
||||
<File>
|
||||
<FileName>retarget_conf.h</FileName>
|
||||
<FileType>5</FileType>
|
||||
<FilePath>.\platform\retarget\retarget_conf.h</FilePath>
|
||||
</File>
|
||||
</Files>
|
||||
</Group>
|
||||
</Groups>
|
||||
</Target>
|
||||
</Targets>
|
||||
|
||||
<RTE>
|
||||
<apis/>
|
||||
<components/>
|
||||
<files/>
|
||||
</RTE>
|
||||
|
||||
<LayerInfo>
|
||||
<Layers>
|
||||
<Layer>
|
||||
<LayName>UKSI</LayName>
|
||||
<LayPrjMark>1</LayPrjMark>
|
||||
<LayTitle>Template</LayTitle>
|
||||
</Layer>
|
||||
</Layers>
|
||||
</LayerInfo>
|
||||
|
||||
</Project>
|
||||
867
MDK-ARM/platform/CMSIS/Core/Include/cmsis_armcc.h
Normal file
867
MDK-ARM/platform/CMSIS/Core/Include/cmsis_armcc.h
Normal file
@@ -0,0 +1,867 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_armcc.h
|
||||
* @brief CMSIS compiler ARMCC (ARM compiler V5) header file
|
||||
* @version V5.0.2
|
||||
* @date 13. February 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __CMSIS_ARMCC_H
|
||||
#define __CMSIS_ARMCC_H
|
||||
|
||||
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 400677)
|
||||
#error "Please use ARM Compiler Toolchain V4.0.677 or later!"
|
||||
#endif
|
||||
|
||||
/* CMSIS compiler control architecture macros */
|
||||
#if ((defined (__TARGET_ARCH_6_M ) && (__TARGET_ARCH_6_M == 1)) || \
|
||||
(defined (__TARGET_ARCH_6S_M ) && (__TARGET_ARCH_6S_M == 1)) )
|
||||
#define __ARM_ARCH_6M__ 1
|
||||
#endif
|
||||
|
||||
#if (defined (__TARGET_ARCH_7_M ) && (__TARGET_ARCH_7_M == 1))
|
||||
#define __ARM_ARCH_7M__ 1
|
||||
#endif
|
||||
|
||||
#if (defined (__TARGET_ARCH_7E_M) && (__TARGET_ARCH_7E_M == 1))
|
||||
#define __ARM_ARCH_7EM__ 1
|
||||
#endif
|
||||
|
||||
/* __ARM_ARCH_8M_BASE__ not applicable */
|
||||
/* __ARM_ARCH_8M_MAIN__ not applicable */
|
||||
|
||||
|
||||
/* CMSIS compiler specific defines */
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE __inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static __inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN __declspec(noreturn)
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED __attribute__((used))
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __attribute__((weak))
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __attribute__((packed))
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT __packed struct
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION __packed union
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
#define __UNALIGNED_UINT32(x) (*((__packed uint32_t *)(x)))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) ((*((__packed uint16_t *)(addr))) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
#define __UNALIGNED_UINT16_READ(addr) (*((const __packed uint16_t *)(addr)))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) ((*((__packed uint32_t *)(addr))) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
#define __UNALIGNED_UINT32_READ(addr) (*((const __packed uint32_t *)(addr)))
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#define __RESTRICT __restrict
|
||||
#endif
|
||||
|
||||
/* ########################### Core Function Access ########################### */
|
||||
/** \ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Enable IRQ Interrupts
|
||||
\details Enables IRQ interrupts by clearing the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
/* intrinsic void __enable_irq(); */
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable IRQ Interrupts
|
||||
\details Disables IRQ interrupts by setting the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
/* intrinsic void __disable_irq(); */
|
||||
|
||||
/**
|
||||
\brief Get Control Register
|
||||
\details Returns the content of the Control Register.
|
||||
\return Control Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_CONTROL(void)
|
||||
{
|
||||
register uint32_t __regControl __ASM("control");
|
||||
return(__regControl);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Control Register
|
||||
\details Writes the given value to the Control Register.
|
||||
\param [in] control Control Register value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_CONTROL(uint32_t control)
|
||||
{
|
||||
register uint32_t __regControl __ASM("control");
|
||||
__regControl = control;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get IPSR Register
|
||||
\details Returns the content of the IPSR Register.
|
||||
\return IPSR Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_IPSR(void)
|
||||
{
|
||||
register uint32_t __regIPSR __ASM("ipsr");
|
||||
return(__regIPSR);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get APSR Register
|
||||
\details Returns the content of the APSR Register.
|
||||
\return APSR Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_APSR(void)
|
||||
{
|
||||
register uint32_t __regAPSR __ASM("apsr");
|
||||
return(__regAPSR);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get xPSR Register
|
||||
\details Returns the content of the xPSR Register.
|
||||
\return xPSR Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_xPSR(void)
|
||||
{
|
||||
register uint32_t __regXPSR __ASM("xpsr");
|
||||
return(__regXPSR);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Process Stack Pointer
|
||||
\details Returns the current value of the Process Stack Pointer (PSP).
|
||||
\return PSP Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_PSP(void)
|
||||
{
|
||||
register uint32_t __regProcessStackPointer __ASM("psp");
|
||||
return(__regProcessStackPointer);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Process Stack Pointer
|
||||
\details Assigns the given value to the Process Stack Pointer (PSP).
|
||||
\param [in] topOfProcStack Process Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_PSP(uint32_t topOfProcStack)
|
||||
{
|
||||
register uint32_t __regProcessStackPointer __ASM("psp");
|
||||
__regProcessStackPointer = topOfProcStack;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Main Stack Pointer
|
||||
\details Returns the current value of the Main Stack Pointer (MSP).
|
||||
\return MSP Register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_MSP(void)
|
||||
{
|
||||
register uint32_t __regMainStackPointer __ASM("msp");
|
||||
return(__regMainStackPointer);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Main Stack Pointer
|
||||
\details Assigns the given value to the Main Stack Pointer (MSP).
|
||||
\param [in] topOfMainStack Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_MSP(uint32_t topOfMainStack)
|
||||
{
|
||||
register uint32_t __regMainStackPointer __ASM("msp");
|
||||
__regMainStackPointer = topOfMainStack;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Priority Mask
|
||||
\details Returns the current state of the priority mask bit from the Priority Mask Register.
|
||||
\return Priority Mask value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_PRIMASK(void)
|
||||
{
|
||||
register uint32_t __regPriMask __ASM("primask");
|
||||
return(__regPriMask);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Priority Mask
|
||||
\details Assigns the given value to the Priority Mask Register.
|
||||
\param [in] priMask Priority Mask
|
||||
*/
|
||||
__STATIC_INLINE void __set_PRIMASK(uint32_t priMask)
|
||||
{
|
||||
register uint32_t __regPriMask __ASM("primask");
|
||||
__regPriMask = (priMask);
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Enable FIQ
|
||||
\details Enables FIQ interrupts by clearing the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
#define __enable_fault_irq __enable_fiq
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable FIQ
|
||||
\details Disables FIQ interrupts by setting the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
#define __disable_fault_irq __disable_fiq
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Base Priority
|
||||
\details Returns the current value of the Base Priority register.
|
||||
\return Base Priority register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_BASEPRI(void)
|
||||
{
|
||||
register uint32_t __regBasePri __ASM("basepri");
|
||||
return(__regBasePri);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority
|
||||
\details Assigns the given value to the Base Priority register.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_BASEPRI(uint32_t basePri)
|
||||
{
|
||||
register uint32_t __regBasePri __ASM("basepri");
|
||||
__regBasePri = (basePri & 0xFFU);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority with condition
|
||||
\details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
|
||||
or the new value increases the BASEPRI priority level.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_BASEPRI_MAX(uint32_t basePri)
|
||||
{
|
||||
register uint32_t __regBasePriMax __ASM("basepri_max");
|
||||
__regBasePriMax = (basePri & 0xFFU);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Fault Mask
|
||||
\details Returns the current value of the Fault Mask register.
|
||||
\return Fault Mask register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_FAULTMASK(void)
|
||||
{
|
||||
register uint32_t __regFaultMask __ASM("faultmask");
|
||||
return(__regFaultMask);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Fault Mask
|
||||
\details Assigns the given value to the Fault Mask register.
|
||||
\param [in] faultMask Fault Mask value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_FAULTMASK(uint32_t faultMask)
|
||||
{
|
||||
register uint32_t __regFaultMask __ASM("faultmask");
|
||||
__regFaultMask = (faultMask & (uint32_t)1U);
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Get FPSCR
|
||||
\details Returns the current value of the Floating Point Status/Control register.
|
||||
\return Floating Point Status/Control register value
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __get_FPSCR(void)
|
||||
{
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
register uint32_t __regfpscr __ASM("fpscr");
|
||||
return(__regfpscr);
|
||||
#else
|
||||
return(0U);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set FPSCR
|
||||
\details Assigns the given value to the Floating Point Status/Control register.
|
||||
\param [in] fpscr Floating Point Status/Control value to set
|
||||
*/
|
||||
__STATIC_INLINE void __set_FPSCR(uint32_t fpscr)
|
||||
{
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
register uint32_t __regfpscr __ASM("fpscr");
|
||||
__regfpscr = (fpscr);
|
||||
#else
|
||||
(void)fpscr;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */
|
||||
|
||||
|
||||
|
||||
/*@} end of CMSIS_Core_RegAccFunctions */
|
||||
|
||||
|
||||
/* ########################## Core Instruction Access ######################### */
|
||||
/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
|
||||
Access to dedicated instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief No Operation
|
||||
\details No Operation does nothing. This instruction can be used for code alignment purposes.
|
||||
*/
|
||||
#define __NOP __nop
|
||||
|
||||
|
||||
/**
|
||||
\brief Wait For Interrupt
|
||||
\details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFI __wfi
|
||||
|
||||
|
||||
/**
|
||||
\brief Wait For Event
|
||||
\details Wait For Event is a hint instruction that permits the processor to enter
|
||||
a low-power state until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFE __wfe
|
||||
|
||||
|
||||
/**
|
||||
\brief Send Event
|
||||
\details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
|
||||
*/
|
||||
#define __SEV __sev
|
||||
|
||||
|
||||
/**
|
||||
\brief Instruction Synchronization Barrier
|
||||
\details Instruction Synchronization Barrier flushes the pipeline in the processor,
|
||||
so that all instructions following the ISB are fetched from cache or memory,
|
||||
after the instruction has been completed.
|
||||
*/
|
||||
#define __ISB() do {\
|
||||
__schedule_barrier();\
|
||||
__isb(0xF);\
|
||||
__schedule_barrier();\
|
||||
} while (0U)
|
||||
|
||||
/**
|
||||
\brief Data Synchronization Barrier
|
||||
\details Acts as a special kind of Data Memory Barrier.
|
||||
It completes when all explicit memory accesses before this instruction complete.
|
||||
*/
|
||||
#define __DSB() do {\
|
||||
__schedule_barrier();\
|
||||
__dsb(0xF);\
|
||||
__schedule_barrier();\
|
||||
} while (0U)
|
||||
|
||||
/**
|
||||
\brief Data Memory Barrier
|
||||
\details Ensures the apparent order of the explicit memory operations before
|
||||
and after the instruction, without ensuring their completion.
|
||||
*/
|
||||
#define __DMB() do {\
|
||||
__schedule_barrier();\
|
||||
__dmb(0xF);\
|
||||
__schedule_barrier();\
|
||||
} while (0U)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (32 bit)
|
||||
\details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#define __REV __rev
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#ifndef __NO_EMBEDDED_ASM
|
||||
__attribute__((section(".rev16_text"))) __STATIC_INLINE __ASM uint32_t __REV16(uint32_t value)
|
||||
{
|
||||
rev16 r0, r0
|
||||
bx lr
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#ifndef __NO_EMBEDDED_ASM
|
||||
__attribute__((section(".revsh_text"))) __STATIC_INLINE __ASM int16_t __REVSH(int16_t value)
|
||||
{
|
||||
revsh r0, r0
|
||||
bx lr
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right in unsigned value (32 bit)
|
||||
\details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
|
||||
\param [in] op1 Value to rotate
|
||||
\param [in] op2 Number of Bits to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
#define __ROR __ror
|
||||
|
||||
|
||||
/**
|
||||
\brief Breakpoint
|
||||
\details Causes the processor to enter Debug state.
|
||||
Debug tools can use this to investigate system state when the instruction at a particular address is reached.
|
||||
\param [in] value is ignored by the processor.
|
||||
If required, a debugger can use it to store additional information about the breakpoint.
|
||||
*/
|
||||
#define __BKPT(value) __breakpoint(value)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse bit order of value
|
||||
\details Reverses the bit order of the given value.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) )
|
||||
#define __RBIT __rbit
|
||||
#else
|
||||
__attribute__((always_inline)) __STATIC_INLINE uint32_t __RBIT(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
|
||||
|
||||
result = value; /* r will be reversed bits of v; first get LSB of v */
|
||||
for (value >>= 1U; value != 0U; value >>= 1U)
|
||||
{
|
||||
result <<= 1U;
|
||||
result |= value & 1U;
|
||||
s--;
|
||||
}
|
||||
result <<= s; /* shift when v's highest bits are zero */
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Count leading zeros
|
||||
\details Counts the number of leading zeros of a data value.
|
||||
\param [in] value Value to count the leading zeros
|
||||
\return number of leading zeros in value
|
||||
*/
|
||||
#define __CLZ __clz
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (8 bit)
|
||||
\details Executes a exclusive LDR instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __LDREXB(ptr) ((uint8_t ) __ldrex(ptr))
|
||||
#else
|
||||
#define __LDREXB(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint8_t ) __ldrex(ptr)) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (16 bit)
|
||||
\details Executes a exclusive LDR instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __LDREXH(ptr) ((uint16_t) __ldrex(ptr))
|
||||
#else
|
||||
#define __LDREXH(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint16_t) __ldrex(ptr)) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (32 bit)
|
||||
\details Executes a exclusive LDR instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __LDREXW(ptr) ((uint32_t ) __ldrex(ptr))
|
||||
#else
|
||||
#define __LDREXW(ptr) _Pragma("push") _Pragma("diag_suppress 3731") ((uint32_t ) __ldrex(ptr)) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (8 bit)
|
||||
\details Executes a exclusive STR instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __STREXB(value, ptr) __strex(value, ptr)
|
||||
#else
|
||||
#define __STREXB(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (16 bit)
|
||||
\details Executes a exclusive STR instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __STREXH(value, ptr) __strex(value, ptr)
|
||||
#else
|
||||
#define __STREXH(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (32 bit)
|
||||
\details Executes a exclusive STR instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#if defined(__ARMCC_VERSION) && (__ARMCC_VERSION < 5060020)
|
||||
#define __STREXW(value, ptr) __strex(value, ptr)
|
||||
#else
|
||||
#define __STREXW(value, ptr) _Pragma("push") _Pragma("diag_suppress 3731") __strex(value, ptr) _Pragma("pop")
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Remove the exclusive lock
|
||||
\details Removes the exclusive lock which is created by LDREX.
|
||||
*/
|
||||
#define __CLREX __clrex
|
||||
|
||||
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __SSAT __ssat
|
||||
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __USAT __usat
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right with Extend (32 bit)
|
||||
\details Moves each bit of a bitstring right by one bit.
|
||||
The carry input is shifted in at the left end of the bitstring.
|
||||
\param [in] value Value to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
#ifndef __NO_EMBEDDED_ASM
|
||||
__attribute__((section(".rrx_text"))) __STATIC_INLINE __ASM uint32_t __RRX(uint32_t value)
|
||||
{
|
||||
rrx r0, r0
|
||||
bx lr
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
#define __LDRBT(ptr) ((uint8_t ) __ldrt(ptr))
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
#define __LDRHT(ptr) ((uint16_t) __ldrt(ptr))
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
#define __LDRT(ptr) ((uint32_t ) __ldrt(ptr))
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
#define __STRBT(value, ptr) __strt(value, ptr)
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
#define __STRHT(value, ptr) __strt(value, ptr)
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
#define __STRT(value, ptr) __strt(value, ptr)
|
||||
|
||||
#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */
|
||||
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
__attribute__((always_inline)) __STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if ((sat >= 1U) && (sat <= 32U))
|
||||
{
|
||||
const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
|
||||
const int32_t min = -1 - max ;
|
||||
if (val > max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < min)
|
||||
{
|
||||
return min;
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
__attribute__((always_inline)) __STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if (sat <= 31U)
|
||||
{
|
||||
const uint32_t max = ((1U << sat) - 1U);
|
||||
if (val > (int32_t)max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < 0)
|
||||
{
|
||||
return 0U;
|
||||
}
|
||||
}
|
||||
return (uint32_t)val;
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_Core_InstructionInterface */
|
||||
|
||||
|
||||
/* ################### Compiler specific Intrinsics ########################### */
|
||||
/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
|
||||
Access to dedicated SIMD instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
#if ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) )
|
||||
|
||||
#define __SADD8 __sadd8
|
||||
#define __QADD8 __qadd8
|
||||
#define __SHADD8 __shadd8
|
||||
#define __UADD8 __uadd8
|
||||
#define __UQADD8 __uqadd8
|
||||
#define __UHADD8 __uhadd8
|
||||
#define __SSUB8 __ssub8
|
||||
#define __QSUB8 __qsub8
|
||||
#define __SHSUB8 __shsub8
|
||||
#define __USUB8 __usub8
|
||||
#define __UQSUB8 __uqsub8
|
||||
#define __UHSUB8 __uhsub8
|
||||
#define __SADD16 __sadd16
|
||||
#define __QADD16 __qadd16
|
||||
#define __SHADD16 __shadd16
|
||||
#define __UADD16 __uadd16
|
||||
#define __UQADD16 __uqadd16
|
||||
#define __UHADD16 __uhadd16
|
||||
#define __SSUB16 __ssub16
|
||||
#define __QSUB16 __qsub16
|
||||
#define __SHSUB16 __shsub16
|
||||
#define __USUB16 __usub16
|
||||
#define __UQSUB16 __uqsub16
|
||||
#define __UHSUB16 __uhsub16
|
||||
#define __SASX __sasx
|
||||
#define __QASX __qasx
|
||||
#define __SHASX __shasx
|
||||
#define __UASX __uasx
|
||||
#define __UQASX __uqasx
|
||||
#define __UHASX __uhasx
|
||||
#define __SSAX __ssax
|
||||
#define __QSAX __qsax
|
||||
#define __SHSAX __shsax
|
||||
#define __USAX __usax
|
||||
#define __UQSAX __uqsax
|
||||
#define __UHSAX __uhsax
|
||||
#define __USAD8 __usad8
|
||||
#define __USADA8 __usada8
|
||||
#define __SSAT16 __ssat16
|
||||
#define __USAT16 __usat16
|
||||
#define __UXTB16 __uxtb16
|
||||
#define __UXTAB16 __uxtab16
|
||||
#define __SXTB16 __sxtb16
|
||||
#define __SXTAB16 __sxtab16
|
||||
#define __SMUAD __smuad
|
||||
#define __SMUADX __smuadx
|
||||
#define __SMLAD __smlad
|
||||
#define __SMLADX __smladx
|
||||
#define __SMLALD __smlald
|
||||
#define __SMLALDX __smlaldx
|
||||
#define __SMUSD __smusd
|
||||
#define __SMUSDX __smusdx
|
||||
#define __SMLSD __smlsd
|
||||
#define __SMLSDX __smlsdx
|
||||
#define __SMLSLD __smlsld
|
||||
#define __SMLSLDX __smlsldx
|
||||
#define __SEL __sel
|
||||
#define __QADD __qadd
|
||||
#define __QSUB __qsub
|
||||
|
||||
#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \
|
||||
((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) )
|
||||
|
||||
#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \
|
||||
((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) )
|
||||
|
||||
#define __SMMLA(ARG1,ARG2,ARG3) ( (int32_t)((((int64_t)(ARG1) * (ARG2)) + \
|
||||
((int64_t)(ARG3) << 32U) ) >> 32U))
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7EM__) && (__ARM_ARCH_7EM__ == 1)) ) */
|
||||
/*@} end of group CMSIS_SIMD_intrinsics */
|
||||
|
||||
|
||||
#endif /* __CMSIS_ARMCC_H */
|
||||
1815
MDK-ARM/platform/CMSIS/Core/Include/cmsis_armclang.h
Normal file
1815
MDK-ARM/platform/CMSIS/Core/Include/cmsis_armclang.h
Normal file
@@ -0,0 +1,1815 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_armclang.h
|
||||
* @brief CMSIS compiler ARMCLANG (ARM compiler V6) header file
|
||||
* @version V5.0.3
|
||||
* @date 27. March 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/*lint -esym(9058, IRQn)*/ /* disable MISRA 2012 Rule 2.4 for IRQn */
|
||||
|
||||
#ifndef __CMSIS_ARMCLANG_H
|
||||
#define __CMSIS_ARMCLANG_H
|
||||
|
||||
#pragma clang system_header /* treat file as system include file */
|
||||
|
||||
#ifndef __ARM_COMPAT_H
|
||||
#include <arm_compat.h> /* Compatibility header for ARM Compiler 5 intrinsics */
|
||||
#endif
|
||||
|
||||
/* CMSIS compiler specific defines */
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE __inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static __inline
|
||||
#endif
|
||||
#ifndef __STATIC_FORCEINLINE
|
||||
#define __STATIC_FORCEINLINE __attribute__((always_inline)) static __inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN __attribute__((__noreturn__))
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED __attribute__((used))
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __attribute__((weak))
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT struct __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION union __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wpacked"
|
||||
/*lint -esym(9058, T_UINT32)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32 */
|
||||
struct __attribute__((packed)) T_UINT32 { uint32_t v; };
|
||||
#pragma clang diagnostic pop
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wpacked"
|
||||
/*lint -esym(9058, T_UINT16_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_WRITE */
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#pragma clang diagnostic pop
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wpacked"
|
||||
/*lint -esym(9058, T_UINT16_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT16_READ */
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#pragma clang diagnostic pop
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wpacked"
|
||||
/*lint -esym(9058, T_UINT32_WRITE)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_WRITE */
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#pragma clang diagnostic pop
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
#pragma clang diagnostic push
|
||||
#pragma clang diagnostic ignored "-Wpacked"
|
||||
/*lint -esym(9058, T_UINT32_READ)*/ /* disable MISRA 2012 Rule 2.4 for T_UINT32_READ */
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#pragma clang diagnostic pop
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#define __RESTRICT __restrict
|
||||
#endif
|
||||
|
||||
|
||||
/* ########################### Core Function Access ########################### */
|
||||
/** \ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Enable IRQ Interrupts
|
||||
\details Enables IRQ interrupts by clearing the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
/* intrinsic void __enable_irq(); see arm_compat.h */
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable IRQ Interrupts
|
||||
\details Disables IRQ interrupts by setting the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
/* intrinsic void __disable_irq(); see arm_compat.h */
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Control Register
|
||||
\details Returns the content of the Control Register.
|
||||
\return Control Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_CONTROL(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, control" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Control Register (non-secure)
|
||||
\details Returns the content of the non-secure Control Register when in secure mode.
|
||||
\return non-secure Control Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, control_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Control Register
|
||||
\details Writes the given value to the Control Register.
|
||||
\param [in] control Control Register value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
|
||||
{
|
||||
__ASM volatile ("MSR control, %0" : : "r" (control) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Control Register (non-secure)
|
||||
\details Writes the given value to the non-secure Control Register when in secure state.
|
||||
\param [in] control Control Register value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
|
||||
{
|
||||
__ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get IPSR Register
|
||||
\details Returns the content of the IPSR Register.
|
||||
\return IPSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_IPSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, ipsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get APSR Register
|
||||
\details Returns the content of the APSR Register.
|
||||
\return APSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_APSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, apsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get xPSR Register
|
||||
\details Returns the content of the xPSR Register.
|
||||
\return xPSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_xPSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, xpsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Process Stack Pointer
|
||||
\details Returns the current value of the Process Stack Pointer (PSP).
|
||||
\return PSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PSP(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psp" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Process Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state.
|
||||
\return PSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Process Stack Pointer
|
||||
\details Assigns the given value to the Process Stack Pointer (PSP).
|
||||
\param [in] topOfProcStack Process Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack)
|
||||
{
|
||||
__ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : );
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Process Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state.
|
||||
\param [in] topOfProcStack Process Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
|
||||
{
|
||||
__ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Main Stack Pointer
|
||||
\details Returns the current value of the Main Stack Pointer (MSP).
|
||||
\return MSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_MSP(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msp" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Main Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state.
|
||||
\return MSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Main Stack Pointer
|
||||
\details Assigns the given value to the Main Stack Pointer (MSP).
|
||||
\param [in] topOfMainStack Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack)
|
||||
{
|
||||
__ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : );
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Main Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state.
|
||||
\param [in] topOfMainStack Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
|
||||
{
|
||||
__ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Stack Pointer (SP) when in secure state.
|
||||
\return SP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, sp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state.
|
||||
\param [in] topOfStack Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack)
|
||||
{
|
||||
__ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Priority Mask
|
||||
\details Returns the current state of the priority mask bit from the Priority Mask Register.
|
||||
\return Priority Mask value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, primask" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Priority Mask (non-secure)
|
||||
\details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state.
|
||||
\return Priority Mask value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, primask_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Priority Mask
|
||||
\details Assigns the given value to the Priority Mask Register.
|
||||
\param [in] priMask Priority Mask
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
|
||||
{
|
||||
__ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Priority Mask (non-secure)
|
||||
\details Assigns the given value to the non-secure Priority Mask Register when in secure state.
|
||||
\param [in] priMask Priority Mask
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
|
||||
{
|
||||
__ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Enable FIQ
|
||||
\details Enables FIQ interrupts by clearing the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
#define __enable_fault_irq __enable_fiq /* see arm_compat.h */
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable FIQ
|
||||
\details Disables FIQ interrupts by setting the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
#define __disable_fault_irq __disable_fiq /* see arm_compat.h */
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Base Priority
|
||||
\details Returns the current value of the Base Priority register.
|
||||
\return Base Priority register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, basepri" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Base Priority (non-secure)
|
||||
\details Returns the current value of the non-secure Base Priority register when in secure state.
|
||||
\return Base Priority register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, basepri_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority
|
||||
\details Assigns the given value to the Base Priority register.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Base Priority (non-secure)
|
||||
\details Assigns the given value to the non-secure Base Priority register when in secure state.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority with condition
|
||||
\details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
|
||||
or the new value increases the BASEPRI priority level.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Fault Mask
|
||||
\details Returns the current value of the Fault Mask register.
|
||||
\return Fault Mask register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, faultmask" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Fault Mask (non-secure)
|
||||
\details Returns the current value of the non-secure Fault Mask register when in secure state.
|
||||
\return Fault Mask register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Fault Mask
|
||||
\details Assigns the given value to the Fault Mask register.
|
||||
\param [in] faultMask Fault Mask value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask)
|
||||
{
|
||||
__ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Fault Mask (non-secure)
|
||||
\details Assigns the given value to the non-secure Fault Mask register when in secure state.
|
||||
\param [in] faultMask Fault Mask value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
|
||||
{
|
||||
__ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Get Process Stack Pointer Limit
|
||||
\details Returns the current value of the Process Stack Pointer Limit (PSPLIM).
|
||||
\return PSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psplim" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Get Process Stack Pointer Limit (non-secure)
|
||||
\details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
|
||||
\return PSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psplim_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Process Stack Pointer Limit
|
||||
\details Assigns the given value to the Process Stack Pointer Limit (PSPLIM).
|
||||
\param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit));
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Set Process Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
|
||||
\param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Main Stack Pointer Limit
|
||||
\details Returns the current value of the Main Stack Pointer Limit (MSPLIM).
|
||||
\return MSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msplim" : "=r" (result) );
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Get Main Stack Pointer Limit (non-secure)
|
||||
\details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state.
|
||||
\return MSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msplim_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Main Stack Pointer Limit
|
||||
\details Assigns the given value to the Main Stack Pointer Limit (MSPLIM).
|
||||
\param [in] MainStackPtrLimit Main Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit));
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Set Main Stack Pointer Limit (non-secure)
|
||||
\details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state.
|
||||
\param [in] MainStackPtrLimit Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit));
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Get FPSCR
|
||||
\details Returns the current value of the Floating Point Status/Control register.
|
||||
\return Floating Point Status/Control register value
|
||||
*/
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
#define __get_FPSCR (uint32_t)__builtin_arm_get_fpscr
|
||||
#else
|
||||
#define __get_FPSCR() ((uint32_t)0U)
|
||||
#endif
|
||||
|
||||
/**
|
||||
\brief Set FPSCR
|
||||
\details Assigns the given value to the Floating Point Status/Control register.
|
||||
\param [in] fpscr Floating Point Status/Control value to set
|
||||
*/
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
#define __set_FPSCR __builtin_arm_set_fpscr
|
||||
#else
|
||||
#define __set_FPSCR(x) ((void)(x))
|
||||
#endif
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
|
||||
/*@} end of CMSIS_Core_RegAccFunctions */
|
||||
|
||||
|
||||
/* ########################## Core Instruction Access ######################### */
|
||||
/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
|
||||
Access to dedicated instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
/* Define macros for porting to both thumb1 and thumb2.
|
||||
* For thumb1, use low register (r0-r7), specified by constraint "l"
|
||||
* Otherwise, use general registers, specified by constraint "r" */
|
||||
#if defined (__thumb__) && !defined (__thumb2__)
|
||||
#define __CMSIS_GCC_OUT_REG(r) "=l" (r)
|
||||
#define __CMSIS_GCC_USE_REG(r) "l" (r)
|
||||
#else
|
||||
#define __CMSIS_GCC_OUT_REG(r) "=r" (r)
|
||||
#define __CMSIS_GCC_USE_REG(r) "r" (r)
|
||||
#endif
|
||||
|
||||
/**
|
||||
\brief No Operation
|
||||
\details No Operation does nothing. This instruction can be used for code alignment purposes.
|
||||
*/
|
||||
#define __NOP __builtin_arm_nop
|
||||
|
||||
/**
|
||||
\brief Wait For Interrupt
|
||||
\details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFI __builtin_arm_wfi
|
||||
|
||||
|
||||
/**
|
||||
\brief Wait For Event
|
||||
\details Wait For Event is a hint instruction that permits the processor to enter
|
||||
a low-power state until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFE __builtin_arm_wfe
|
||||
|
||||
|
||||
/**
|
||||
\brief Send Event
|
||||
\details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
|
||||
*/
|
||||
#define __SEV __builtin_arm_sev
|
||||
|
||||
|
||||
/**
|
||||
\brief Instruction Synchronization Barrier
|
||||
\details Instruction Synchronization Barrier flushes the pipeline in the processor,
|
||||
so that all instructions following the ISB are fetched from cache or memory,
|
||||
after the instruction has been completed.
|
||||
*/
|
||||
#define __ISB() __builtin_arm_isb(0xF);
|
||||
|
||||
/**
|
||||
\brief Data Synchronization Barrier
|
||||
\details Acts as a special kind of Data Memory Barrier.
|
||||
It completes when all explicit memory accesses before this instruction complete.
|
||||
*/
|
||||
#define __DSB() __builtin_arm_dsb(0xF);
|
||||
|
||||
|
||||
/**
|
||||
\brief Data Memory Barrier
|
||||
\details Ensures the apparent order of the explicit memory operations before
|
||||
and after the instruction, without ensuring their completion.
|
||||
*/
|
||||
#define __DMB() __builtin_arm_dmb(0xF);
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (32 bit)
|
||||
\details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#define __REV(value) __builtin_bswap32(value)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#define __REV16(value) __ROR(__REV(value), 16)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#define __REVSH(value) (int16_t)__builtin_bswap16(value)
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right in unsigned value (32 bit)
|
||||
\details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
|
||||
\param [in] op1 Value to rotate
|
||||
\param [in] op2 Number of Bits to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
op2 %= 32U;
|
||||
if (op2 == 0U)
|
||||
{
|
||||
return op1;
|
||||
}
|
||||
return (op1 >> op2) | (op1 << (32U - op2));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Breakpoint
|
||||
\details Causes the processor to enter Debug state.
|
||||
Debug tools can use this to investigate system state when the instruction at a particular address is reached.
|
||||
\param [in] value is ignored by the processor.
|
||||
If required, a debugger can use it to store additional information about the breakpoint.
|
||||
*/
|
||||
#define __BKPT(value) __ASM volatile ("bkpt "#value)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse bit order of value
|
||||
\details Reverses the bit order of the given value.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
#define __RBIT __builtin_arm_rbit
|
||||
|
||||
/**
|
||||
\brief Count leading zeros
|
||||
\details Counts the number of leading zeros of a data value.
|
||||
\param [in] value Value to count the leading zeros
|
||||
\return number of leading zeros in value
|
||||
*/
|
||||
#define __CLZ (uint8_t)__builtin_clz
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
/**
|
||||
\brief LDR Exclusive (8 bit)
|
||||
\details Executes a exclusive LDR instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
#define __LDREXB (uint8_t)__builtin_arm_ldrex
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (16 bit)
|
||||
\details Executes a exclusive LDR instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
#define __LDREXH (uint16_t)__builtin_arm_ldrex
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (32 bit)
|
||||
\details Executes a exclusive LDR instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
#define __LDREXW (uint32_t)__builtin_arm_ldrex
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (8 bit)
|
||||
\details Executes a exclusive STR instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STREXB (uint32_t)__builtin_arm_strex
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (16 bit)
|
||||
\details Executes a exclusive STR instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STREXH (uint32_t)__builtin_arm_strex
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (32 bit)
|
||||
\details Executes a exclusive STR instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STREXW (uint32_t)__builtin_arm_strex
|
||||
|
||||
|
||||
/**
|
||||
\brief Remove the exclusive lock
|
||||
\details Removes the exclusive lock which is created by LDREX.
|
||||
*/
|
||||
#define __CLREX __builtin_arm_clrex
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __SSAT __builtin_arm_ssat
|
||||
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __USAT __builtin_arm_usat
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right with Extend (32 bit)
|
||||
\details Moves each bit of a bitstring right by one bit.
|
||||
The carry input is shifted in at the left end of the bitstring.
|
||||
\param [in] value Value to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint8_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint16_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
|
||||
}
|
||||
|
||||
#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if ((sat >= 1U) && (sat <= 32U))
|
||||
{
|
||||
const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
|
||||
const int32_t min = -1 - max ;
|
||||
if (val > max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < min)
|
||||
{
|
||||
return min;
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if (sat <= 31U)
|
||||
{
|
||||
const uint32_t max = ((1U << sat) - 1U);
|
||||
if (val > (int32_t)max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < 0)
|
||||
{
|
||||
return 0U;
|
||||
}
|
||||
}
|
||||
return (uint32_t)val;
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
/**
|
||||
\brief Load-Acquire (8 bit)
|
||||
\details Executes a LDAB instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint8_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire (16 bit)
|
||||
\details Executes a LDAH instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint16_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire (32 bit)
|
||||
\details Executes a LDA instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (8 bit)
|
||||
\details Executes a STLB instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (16 bit)
|
||||
\details Executes a STLH instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (32 bit)
|
||||
\details Executes a STL instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (8 bit)
|
||||
\details Executes a LDAB exclusive instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
#define __LDAEXB (uint8_t)__builtin_arm_ldaex
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (16 bit)
|
||||
\details Executes a LDAH exclusive instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
#define __LDAEXH (uint16_t)__builtin_arm_ldaex
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (32 bit)
|
||||
\details Executes a LDA exclusive instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
#define __LDAEX (uint32_t)__builtin_arm_ldaex
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (8 bit)
|
||||
\details Executes a STLB exclusive instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STLEXB (uint32_t)__builtin_arm_stlex
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (16 bit)
|
||||
\details Executes a STLH exclusive instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STLEXH (uint32_t)__builtin_arm_stlex
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (32 bit)
|
||||
\details Executes a STL exclusive instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
#define __STLEX (uint32_t)__builtin_arm_stlex
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_Core_InstructionInterface */
|
||||
|
||||
|
||||
/* ################### Compiler specific Intrinsics ########################### */
|
||||
/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
|
||||
Access to dedicated SIMD instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usad8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usada8 %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#define __SSAT16(ARG1,ARG2) \
|
||||
({ \
|
||||
int32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("ssat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
#define __USAT16(ARG1,ARG2) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("usat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uxtb16 %0, %1" : "=r" (result) : "r" (op1));
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sxtb16 %0, %1" : "=r" (result) : "r" (op1));
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUAD (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smuad %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smuadx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlad %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smladx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUSD (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smusd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smusdx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlsd %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlsdx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SEL (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sel %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __QADD( int32_t op1, int32_t op2)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("qadd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __QSUB( int32_t op1, int32_t op2)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("qsub %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#if 0
|
||||
#define __PKHBT(ARG1,ARG2,ARG3) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
|
||||
__ASM ("pkhbt %0, %1, %2, lsl %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
#define __PKHTB(ARG1,ARG2,ARG3) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
|
||||
if (ARG3 == 0) \
|
||||
__ASM ("pkhtb %0, %1, %2" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2) ); \
|
||||
else \
|
||||
__ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \
|
||||
__RES; \
|
||||
})
|
||||
#endif
|
||||
|
||||
#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \
|
||||
((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) )
|
||||
|
||||
#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \
|
||||
((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) )
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#endif /* (__ARM_FEATURE_DSP == 1) */
|
||||
/*@} end of group CMSIS_SIMD_intrinsics */
|
||||
|
||||
|
||||
#endif /* __CMSIS_ARMCLANG_H */
|
||||
127
MDK-ARM/platform/CMSIS/Core/Include/cmsis_cmcpp.h
Normal file
127
MDK-ARM/platform/CMSIS/Core/Include/cmsis_cmcpp.h
Normal file
@@ -0,0 +1,127 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_cmcpp.h
|
||||
* @brief CMSIS compiler CMCPP_ARM header file
|
||||
* @version V5.0.2
|
||||
* @date 13. February 2018
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __CMSIS_CMCPP_H
|
||||
#define __CMSIS_CMCPP_H
|
||||
|
||||
/* ignore some GCC warnings */
|
||||
/*#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wsign-conversion"
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter" */
|
||||
|
||||
/* Fallback for __has_builtin */
|
||||
#ifndef __has_builtin
|
||||
#define __has_builtin(x) (0)
|
||||
#endif
|
||||
|
||||
/* CMSIS compiler specific defines */
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
#ifndef __STATIC_FORCEINLINE
|
||||
#define __STATIC_FORCEINLINE static inline /*__attribute__((always_inline)) static inline*/
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN /*__attribute__((__noreturn__))*/
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED /*__attribute__((used))*/
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK /*__attribute__((weak))*/
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __packed
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT __packed struct
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION __packed union
|
||||
#endif
|
||||
|
||||
//#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
/* #pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
struct __attribute__((packed)) T_UINT32 { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif */
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) /*__attribute__((aligned(x)))*/
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#define __RESTRICT /*__restrict*/
|
||||
#endif
|
||||
|
||||
|
||||
/* ########################### Core Function Access ########################### */
|
||||
/** \ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
|
||||
@{
|
||||
*/
|
||||
|
||||
|
||||
#endif /* __CMSISG_CMCPP_H */
|
||||
|
||||
264
MDK-ARM/platform/CMSIS/Core/Include/cmsis_compiler.h
Normal file
264
MDK-ARM/platform/CMSIS/Core/Include/cmsis_compiler.h
Normal file
@@ -0,0 +1,264 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_compiler.h
|
||||
* @brief CMSIS compiler generic header file
|
||||
* @version V5.0.2
|
||||
* @date 13. February 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __CMSIS_COMPILER_H
|
||||
#define __CMSIS_COMPILER_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
/*
|
||||
* ARM Compiler 4/5
|
||||
*/
|
||||
#if defined ( __CC_ARM )
|
||||
#include "cmsis_armcc.h"
|
||||
|
||||
|
||||
/*
|
||||
* ARM Compiler 6 (armclang)
|
||||
*/
|
||||
#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
#include "cmsis_armclang.h"
|
||||
|
||||
|
||||
/*
|
||||
* GNU Compiler
|
||||
*/
|
||||
#elif defined ( __GNUC__ )
|
||||
#include "cmsis_gcc.h"
|
||||
|
||||
|
||||
/*
|
||||
* CMCPP-ARM Compiler
|
||||
*/
|
||||
#elif defined ( __CMCPPARM__ )
|
||||
#include "cmsis_cmcpp.h"
|
||||
|
||||
|
||||
/*
|
||||
* IAR Compiler
|
||||
*/
|
||||
#elif defined ( __ICCARM__ )
|
||||
#include <cmsis_iccarm.h>
|
||||
|
||||
|
||||
/*
|
||||
* TI ARM Compiler
|
||||
*/
|
||||
#elif defined ( __TI_ARM__ )
|
||||
#include <cmsis_ccs.h>
|
||||
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN __attribute__((noreturn))
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED __attribute__((used))
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __attribute__((weak))
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __attribute__((packed))
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT struct __attribute__((packed))
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION union __attribute__((packed))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
struct __attribute__((packed)) T_UINT32 { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void*)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
|
||||
#define __RESTRICT
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* TASKING Compiler
|
||||
*/
|
||||
#elif defined ( __TASKING__ )
|
||||
/*
|
||||
* The CMSIS functions have been implemented as intrinsics in the compiler.
|
||||
* Please use "carm -?i" to get an up to date list of all intrinsics,
|
||||
* Including the CMSIS ones.
|
||||
*/
|
||||
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN __attribute__((noreturn))
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED __attribute__((used))
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __attribute__((weak))
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __packed__
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT struct __packed__
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION union __packed__
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
struct __packed__ T_UINT32 { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) __align(x)
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
|
||||
#define __RESTRICT
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* COSMIC Compiler
|
||||
*/
|
||||
#elif defined ( __CSMC__ )
|
||||
#include <cmsis_csm.h>
|
||||
|
||||
#ifndef __ASM
|
||||
#define __ASM _asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
// NO RETURN is automatically detected hence no warning here
|
||||
#define __NO_RETURN
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#warning No compiler specific solution for __USED. __USED is ignored.
|
||||
#define __USED
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __weak
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED @packed
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT @packed struct
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION @packed union
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
@packed struct T_UINT32 { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#warning No compiler specific solution for __ALIGNED. __ALIGNED is ignored.
|
||||
#define __ALIGNED(x)
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#warning No compiler specific solution for __RESTRICT. __RESTRICT is ignored.
|
||||
#define __RESTRICT
|
||||
#endif
|
||||
|
||||
|
||||
#else
|
||||
#error Unknown compiler.
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* __CMSIS_COMPILER_H */
|
||||
|
||||
2026
MDK-ARM/platform/CMSIS/Core/Include/cmsis_gcc.h
Normal file
2026
MDK-ARM/platform/CMSIS/Core/Include/cmsis_gcc.h
Normal file
@@ -0,0 +1,2026 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_gcc.h
|
||||
* @brief CMSIS compiler GCC header file
|
||||
* @version V5.0.2
|
||||
* @date 13. February 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __CMSIS_GCC_H
|
||||
#define __CMSIS_GCC_H
|
||||
|
||||
/* ignore some GCC warnings */
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wsign-conversion"
|
||||
#pragma GCC diagnostic ignored "-Wconversion"
|
||||
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
||||
|
||||
/* Fallback for __has_builtin */
|
||||
#ifndef __has_builtin
|
||||
#define __has_builtin(x) (0)
|
||||
#endif
|
||||
|
||||
/* CMSIS compiler specific defines */
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
#ifndef __STATIC_FORCEINLINE
|
||||
#define __STATIC_FORCEINLINE __attribute__((always_inline)) static inline
|
||||
#endif
|
||||
#ifndef __NO_RETURN
|
||||
#define __NO_RETURN __attribute__((__noreturn__))
|
||||
#endif
|
||||
#ifndef __USED
|
||||
#define __USED __attribute__((used))
|
||||
#endif
|
||||
#ifndef __WEAK
|
||||
#define __WEAK __attribute__((weak))
|
||||
#endif
|
||||
#ifndef __PACKED
|
||||
#define __PACKED __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __PACKED_STRUCT
|
||||
#define __PACKED_STRUCT struct __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __PACKED_UNION
|
||||
#define __PACKED_UNION union __attribute__((packed, aligned(1)))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
struct __attribute__((packed)) T_UINT32 { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32(x) (((struct T_UINT32 *)(x))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT16_WRITE { uint16_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT16_WRITE(addr, val) (void)((((struct T_UINT16_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT16_READ { uint16_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT16_READ(addr) (((const struct T_UINT16_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT32_WRITE { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32_WRITE(addr, val) (void)((((struct T_UINT32_WRITE *)(void *)(addr))->v) = (val))
|
||||
#endif
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wpacked"
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
__PACKED_STRUCT T_UINT32_READ { uint32_t v; };
|
||||
#pragma GCC diagnostic pop
|
||||
#define __UNALIGNED_UINT32_READ(addr) (((const struct T_UINT32_READ *)(const void *)(addr))->v)
|
||||
#endif
|
||||
#ifndef __ALIGNED
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#endif
|
||||
#ifndef __RESTRICT
|
||||
#define __RESTRICT __restrict
|
||||
#endif
|
||||
|
||||
|
||||
/* ########################### Core Function Access ########################### */
|
||||
/** \ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_RegAccFunctions CMSIS Core Register Access Functions
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Enable IRQ Interrupts
|
||||
\details Enables IRQ interrupts by clearing the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __enable_irq(void)
|
||||
{
|
||||
__ASM volatile ("cpsie i" : : : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable IRQ Interrupts
|
||||
\details Disables IRQ interrupts by setting the I-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __disable_irq(void)
|
||||
{
|
||||
__ASM volatile ("cpsid i" : : : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Control Register
|
||||
\details Returns the content of the Control Register.
|
||||
\return Control Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_CONTROL(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, control" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Control Register (non-secure)
|
||||
\details Returns the content of the non-secure Control Register when in secure mode.
|
||||
\return non-secure Control Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_CONTROL_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, control_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Control Register
|
||||
\details Writes the given value to the Control Register.
|
||||
\param [in] control Control Register value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_CONTROL(uint32_t control)
|
||||
{
|
||||
__ASM volatile ("MSR control, %0" : : "r" (control) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Control Register (non-secure)
|
||||
\details Writes the given value to the non-secure Control Register when in secure state.
|
||||
\param [in] control Control Register value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_CONTROL_NS(uint32_t control)
|
||||
{
|
||||
__ASM volatile ("MSR control_ns, %0" : : "r" (control) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get IPSR Register
|
||||
\details Returns the content of the IPSR Register.
|
||||
\return IPSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_IPSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, ipsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get APSR Register
|
||||
\details Returns the content of the APSR Register.
|
||||
\return APSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_APSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, apsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get xPSR Register
|
||||
\details Returns the content of the xPSR Register.
|
||||
\return xPSR Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_xPSR(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, xpsr" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Process Stack Pointer
|
||||
\details Returns the current value of the Process Stack Pointer (PSP).
|
||||
\return PSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PSP(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psp" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Process Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Process Stack Pointer (PSP) when in secure state.
|
||||
\return PSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PSP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Process Stack Pointer
|
||||
\details Assigns the given value to the Process Stack Pointer (PSP).
|
||||
\param [in] topOfProcStack Process Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PSP(uint32_t topOfProcStack)
|
||||
{
|
||||
__ASM volatile ("MSR psp, %0" : : "r" (topOfProcStack) : );
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Process Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Process Stack Pointer (PSP) when in secure state.
|
||||
\param [in] topOfProcStack Process Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PSP_NS(uint32_t topOfProcStack)
|
||||
{
|
||||
__ASM volatile ("MSR psp_ns, %0" : : "r" (topOfProcStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Main Stack Pointer
|
||||
\details Returns the current value of the Main Stack Pointer (MSP).
|
||||
\return MSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_MSP(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msp" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Main Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Main Stack Pointer (MSP) when in secure state.
|
||||
\return MSP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_MSP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Main Stack Pointer
|
||||
\details Assigns the given value to the Main Stack Pointer (MSP).
|
||||
\param [in] topOfMainStack Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_MSP(uint32_t topOfMainStack)
|
||||
{
|
||||
__ASM volatile ("MSR msp, %0" : : "r" (topOfMainStack) : );
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Main Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Main Stack Pointer (MSP) when in secure state.
|
||||
\param [in] topOfMainStack Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_MSP_NS(uint32_t topOfMainStack)
|
||||
{
|
||||
__ASM volatile ("MSR msp_ns, %0" : : "r" (topOfMainStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Stack Pointer (non-secure)
|
||||
\details Returns the current value of the non-secure Stack Pointer (SP) when in secure state.
|
||||
\return SP Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_SP_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, sp_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Stack Pointer (SP) when in secure state.
|
||||
\param [in] topOfStack Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_SP_NS(uint32_t topOfStack)
|
||||
{
|
||||
__ASM volatile ("MSR sp_ns, %0" : : "r" (topOfStack) : );
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Priority Mask
|
||||
\details Returns the current state of the priority mask bit from the Priority Mask Register.
|
||||
\return Priority Mask value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PRIMASK(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, primask" : "=r" (result) :: "memory");
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Priority Mask (non-secure)
|
||||
\details Returns the current state of the non-secure priority mask bit from the Priority Mask Register when in secure state.
|
||||
\return Priority Mask value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PRIMASK_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, primask_ns" : "=r" (result) :: "memory");
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Priority Mask
|
||||
\details Assigns the given value to the Priority Mask Register.
|
||||
\param [in] priMask Priority Mask
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PRIMASK(uint32_t priMask)
|
||||
{
|
||||
__ASM volatile ("MSR primask, %0" : : "r" (priMask) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Priority Mask (non-secure)
|
||||
\details Assigns the given value to the non-secure Priority Mask Register when in secure state.
|
||||
\param [in] priMask Priority Mask
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PRIMASK_NS(uint32_t priMask)
|
||||
{
|
||||
__ASM volatile ("MSR primask_ns, %0" : : "r" (priMask) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Enable FIQ
|
||||
\details Enables FIQ interrupts by clearing the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __enable_fault_irq(void)
|
||||
{
|
||||
__ASM volatile ("cpsie f" : : : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable FIQ
|
||||
\details Disables FIQ interrupts by setting the F-bit in the CPSR.
|
||||
Can only be executed in Privileged modes.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __disable_fault_irq(void)
|
||||
{
|
||||
__ASM volatile ("cpsid f" : : : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Base Priority
|
||||
\details Returns the current value of the Base Priority register.
|
||||
\return Base Priority register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_BASEPRI(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, basepri" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Base Priority (non-secure)
|
||||
\details Returns the current value of the non-secure Base Priority register when in secure state.
|
||||
\return Base Priority register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_BASEPRI_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, basepri_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority
|
||||
\details Assigns the given value to the Base Priority register.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_BASEPRI(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Base Priority (non-secure)
|
||||
\details Assigns the given value to the non-secure Base Priority register when in secure state.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_BASEPRI_NS(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri_ns, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Base Priority with condition
|
||||
\details Assigns the given value to the Base Priority register only if BASEPRI masking is disabled,
|
||||
or the new value increases the BASEPRI priority level.
|
||||
\param [in] basePri Base Priority value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_BASEPRI_MAX(uint32_t basePri)
|
||||
{
|
||||
__ASM volatile ("MSR basepri_max, %0" : : "r" (basePri) : "memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Fault Mask
|
||||
\details Returns the current value of the Fault Mask register.
|
||||
\return Fault Mask register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_FAULTMASK(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, faultmask" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Get Fault Mask (non-secure)
|
||||
\details Returns the current value of the non-secure Fault Mask register when in secure state.
|
||||
\return Fault Mask register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_FAULTMASK_NS(void)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, faultmask_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Fault Mask
|
||||
\details Assigns the given value to the Fault Mask register.
|
||||
\param [in] faultMask Fault Mask value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_FAULTMASK(uint32_t faultMask)
|
||||
{
|
||||
__ASM volatile ("MSR faultmask, %0" : : "r" (faultMask) : "memory");
|
||||
}
|
||||
|
||||
|
||||
#if (defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3))
|
||||
/**
|
||||
\brief Set Fault Mask (non-secure)
|
||||
\details Assigns the given value to the non-secure Fault Mask register when in secure state.
|
||||
\param [in] faultMask Fault Mask value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_FAULTMASK_NS(uint32_t faultMask)
|
||||
{
|
||||
__ASM volatile ("MSR faultmask_ns, %0" : : "r" (faultMask) : "memory");
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Get Process Stack Pointer Limit
|
||||
\details Returns the current value of the Process Stack Pointer Limit (PSPLIM).
|
||||
\return PSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_PSPLIM(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psplim" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Get Process Stack Pointer Limit (non-secure)
|
||||
\details Returns the current value of the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
|
||||
\return PSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_PSPLIM_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, psplim_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Process Stack Pointer Limit
|
||||
\details Assigns the given value to the Process Stack Pointer Limit (PSPLIM).
|
||||
\param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_PSPLIM(uint32_t ProcStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR psplim, %0" : : "r" (ProcStackPtrLimit));
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Set Process Stack Pointer (non-secure)
|
||||
\details Assigns the given value to the non-secure Process Stack Pointer Limit (PSPLIM) when in secure state.
|
||||
\param [in] ProcStackPtrLimit Process Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_PSPLIM_NS(uint32_t ProcStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR psplim_ns, %0\n" : : "r" (ProcStackPtrLimit));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Main Stack Pointer Limit
|
||||
\details Returns the current value of the Main Stack Pointer Limit (MSPLIM).
|
||||
\return MSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_MSPLIM(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msplim" : "=r" (result) );
|
||||
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Get Main Stack Pointer Limit (non-secure)
|
||||
\details Returns the current value of the non-secure Main Stack Pointer Limit(MSPLIM) when in secure state.
|
||||
\return MSPLIM Register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __TZ_get_MSPLIM_NS(void)
|
||||
{
|
||||
register uint32_t result;
|
||||
|
||||
__ASM volatile ("MRS %0, msplim_ns" : "=r" (result) );
|
||||
return(result);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Main Stack Pointer Limit
|
||||
\details Assigns the given value to the Main Stack Pointer Limit (MSPLIM).
|
||||
\param [in] MainStackPtrLimit Main Stack Pointer Limit value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_MSPLIM(uint32_t MainStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR msplim, %0" : : "r" (MainStackPtrLimit));
|
||||
}
|
||||
|
||||
|
||||
#if ((defined (__ARM_FEATURE_CMSE ) && (__ARM_FEATURE_CMSE == 3)) && \
|
||||
(defined (__ARM_ARCH_8M_MAIN__) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Set Main Stack Pointer Limit (non-secure)
|
||||
\details Assigns the given value to the non-secure Main Stack Pointer Limit (MSPLIM) when in secure state.
|
||||
\param [in] MainStackPtrLimit Main Stack Pointer value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __TZ_set_MSPLIM_NS(uint32_t MainStackPtrLimit)
|
||||
{
|
||||
__ASM volatile ("MSR msplim_ns, %0" : : "r" (MainStackPtrLimit));
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
|
||||
/**
|
||||
\brief Get FPSCR
|
||||
\details Returns the current value of the Floating Point Status/Control register.
|
||||
\return Floating Point Status/Control register value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __get_FPSCR(void)
|
||||
{
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
#if __has_builtin(__builtin_arm_get_fpscr) || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)
|
||||
/* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */
|
||||
return __builtin_arm_get_fpscr();
|
||||
#else
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("VMRS %0, fpscr" : "=r" (result) );
|
||||
return(result);
|
||||
#endif
|
||||
#else
|
||||
return(0U);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set FPSCR
|
||||
\details Assigns the given value to the Floating Point Status/Control register.
|
||||
\param [in] fpscr Floating Point Status/Control value to set
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __set_FPSCR(uint32_t fpscr)
|
||||
{
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
#if __has_builtin(__builtin_arm_set_fpscr) || (__GNUC__ > 7) || (__GNUC__ == 7 && __GNUC_MINOR__ >= 2)
|
||||
/* see https://gcc.gnu.org/ml/gcc-patches/2017-04/msg00443.html */
|
||||
__builtin_arm_set_fpscr(fpscr);
|
||||
#else
|
||||
__ASM volatile ("VMSR fpscr, %0" : : "r" (fpscr) : "vfpcc", "memory");
|
||||
#endif
|
||||
#else
|
||||
(void)fpscr;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
|
||||
/*@} end of CMSIS_Core_RegAccFunctions */
|
||||
|
||||
|
||||
/* ########################## Core Instruction Access ######################### */
|
||||
/** \defgroup CMSIS_Core_InstructionInterface CMSIS Core Instruction Interface
|
||||
Access to dedicated instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
/* Define macros for porting to both thumb1 and thumb2.
|
||||
* For thumb1, use low register (r0-r7), specified by constraint "l"
|
||||
* Otherwise, use general registers, specified by constraint "r" */
|
||||
#if defined (__thumb__) && !defined (__thumb2__)
|
||||
#define __CMSIS_GCC_OUT_REG(r) "=l" (r)
|
||||
#define __CMSIS_GCC_RW_REG(r) "+l" (r)
|
||||
#define __CMSIS_GCC_USE_REG(r) "l" (r)
|
||||
#else
|
||||
#define __CMSIS_GCC_OUT_REG(r) "=r" (r)
|
||||
#define __CMSIS_GCC_RW_REG(r) "+r" (r)
|
||||
#define __CMSIS_GCC_USE_REG(r) "r" (r)
|
||||
#endif
|
||||
|
||||
/**
|
||||
\brief No Operation
|
||||
\details No Operation does nothing. This instruction can be used for code alignment purposes.
|
||||
*/
|
||||
#define __NOP() __ASM volatile ("nop")
|
||||
|
||||
/**
|
||||
\brief Wait For Interrupt
|
||||
\details Wait For Interrupt is a hint instruction that suspends execution until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFI() __ASM volatile ("wfi")
|
||||
|
||||
|
||||
/**
|
||||
\brief Wait For Event
|
||||
\details Wait For Event is a hint instruction that permits the processor to enter
|
||||
a low-power state until one of a number of events occurs.
|
||||
*/
|
||||
#define __WFE() __ASM volatile ("wfe")
|
||||
|
||||
|
||||
/**
|
||||
\brief Send Event
|
||||
\details Send Event is a hint instruction. It causes an event to be signaled to the CPU.
|
||||
*/
|
||||
#define __SEV() __ASM volatile ("sev")
|
||||
|
||||
|
||||
/**
|
||||
\brief Instruction Synchronization Barrier
|
||||
\details Instruction Synchronization Barrier flushes the pipeline in the processor,
|
||||
so that all instructions following the ISB are fetched from cache or memory,
|
||||
after the instruction has been completed.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __ISB(void)
|
||||
{
|
||||
__ASM volatile ("isb 0xF":::"memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Data Synchronization Barrier
|
||||
\details Acts as a special kind of Data Memory Barrier.
|
||||
It completes when all explicit memory accesses before this instruction complete.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __DSB(void)
|
||||
{
|
||||
__ASM volatile ("dsb 0xF":::"memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Data Memory Barrier
|
||||
\details Ensures the apparent order of the explicit memory operations before
|
||||
and after the instruction, without ensuring their completion.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __DMB(void)
|
||||
{
|
||||
__ASM volatile ("dmb 0xF":::"memory");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (32 bit)
|
||||
\details Reverses the byte order in unsigned integer value. For example, 0x12345678 becomes 0x78563412.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __REV(uint32_t value)
|
||||
{
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)
|
||||
return __builtin_bswap32(value);
|
||||
#else
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("rev %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order within each halfword of a word. For example, 0x12345678 becomes 0x34127856.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __REV16(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("rev16 %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse byte order (16 bit)
|
||||
\details Reverses the byte order in a 16-bit value and returns the signed 16-bit result. For example, 0x0080 becomes 0x8000.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
__STATIC_FORCEINLINE int16_t __REVSH(int16_t value)
|
||||
{
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
||||
return (int16_t)__builtin_bswap16(value);
|
||||
#else
|
||||
int16_t result;
|
||||
|
||||
__ASM volatile ("revsh %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right in unsigned value (32 bit)
|
||||
\details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
|
||||
\param [in] op1 Value to rotate
|
||||
\param [in] op2 Number of Bits to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
op2 %= 32U;
|
||||
if (op2 == 0U)
|
||||
{
|
||||
return op1;
|
||||
}
|
||||
return (op1 >> op2) | (op1 << (32U - op2));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Breakpoint
|
||||
\details Causes the processor to enter Debug state.
|
||||
Debug tools can use this to investigate system state when the instruction at a particular address is reached.
|
||||
\param [in] value is ignored by the processor.
|
||||
If required, a debugger can use it to store additional information about the breakpoint.
|
||||
*/
|
||||
#define __BKPT(value) __ASM volatile ("bkpt "#value)
|
||||
|
||||
|
||||
/**
|
||||
\brief Reverse bit order of value
|
||||
\details Reverses the bit order of the given value.
|
||||
\param [in] value Value to reverse
|
||||
\return Reversed value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __RBIT(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
__ASM volatile ("rbit %0, %1" : "=r" (result) : "r" (value) );
|
||||
#else
|
||||
uint32_t s = (4U /*sizeof(v)*/ * 8U) - 1U; /* extra shift needed at end */
|
||||
|
||||
result = value; /* r will be reversed bits of v; first get LSB of v */
|
||||
for (value >>= 1U; value != 0U; value >>= 1U)
|
||||
{
|
||||
result <<= 1U;
|
||||
result |= value & 1U;
|
||||
s--;
|
||||
}
|
||||
result <<= s; /* shift when v's highest bits are zero */
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Count leading zeros
|
||||
\details Counts the number of leading zeros of a data value.
|
||||
\param [in] value Value to count the leading zeros
|
||||
\return number of leading zeros in value
|
||||
*/
|
||||
#define __CLZ __builtin_clz
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
/**
|
||||
\brief LDR Exclusive (8 bit)
|
||||
\details Executes a exclusive LDR instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDREXB(volatile uint8_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
||||
__ASM volatile ("ldrexb %0, %1" : "=r" (result) : "Q" (*addr) );
|
||||
#else
|
||||
/* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
|
||||
accepted by assembler. So has to use following less efficient pattern.
|
||||
*/
|
||||
__ASM volatile ("ldrexb %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );
|
||||
#endif
|
||||
return ((uint8_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (16 bit)
|
||||
\details Executes a exclusive LDR instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDREXH(volatile uint16_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
||||
__ASM volatile ("ldrexh %0, %1" : "=r" (result) : "Q" (*addr) );
|
||||
#else
|
||||
/* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
|
||||
accepted by assembler. So has to use following less efficient pattern.
|
||||
*/
|
||||
__ASM volatile ("ldrexh %0, [%1]" : "=r" (result) : "r" (addr) : "memory" );
|
||||
#endif
|
||||
return ((uint16_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDR Exclusive (32 bit)
|
||||
\details Executes a exclusive LDR instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDREXW(volatile uint32_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldrex %0, %1" : "=r" (result) : "Q" (*addr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (8 bit)
|
||||
\details Executes a exclusive STR instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STREXB(uint8_t value, volatile uint8_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("strexb %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (16 bit)
|
||||
\details Executes a exclusive STR instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STREXH(uint16_t value, volatile uint16_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("strexh %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" ((uint32_t)value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STR Exclusive (32 bit)
|
||||
\details Executes a exclusive STR instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STREXW(uint32_t value, volatile uint32_t *addr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("strex %0, %2, %1" : "=&r" (result), "=Q" (*addr) : "r" (value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Remove the exclusive lock
|
||||
\details Removes the exclusive lock which is created by LDREX.
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __CLREX(void)
|
||||
{
|
||||
__ASM volatile ("clrex" ::: "memory");
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) )
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] ARG1 Value to be saturated
|
||||
\param [in] ARG2 Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __SSAT(ARG1,ARG2) \
|
||||
__extension__ \
|
||||
({ \
|
||||
int32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("ssat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] ARG1 Value to be saturated
|
||||
\param [in] ARG2 Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
#define __USAT(ARG1,ARG2) \
|
||||
__extension__ \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("usat %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
|
||||
/**
|
||||
\brief Rotate Right with Extend (32 bit)
|
||||
\details Moves each bit of a bitstring right by one bit.
|
||||
The carry input is shifted in at the left end of the bitstring.
|
||||
\param [in] value Value to rotate
|
||||
\return Rotated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __RRX(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("rrx %0, %1" : __CMSIS_GCC_OUT_REG (result) : __CMSIS_GCC_USE_REG (value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDRBT(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
||||
__ASM volatile ("ldrbt %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
#else
|
||||
/* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
|
||||
accepted by assembler. So has to use following less efficient pattern.
|
||||
*/
|
||||
__ASM volatile ("ldrbt %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );
|
||||
#endif
|
||||
return ((uint8_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDRHT(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
||||
__ASM volatile ("ldrht %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
#else
|
||||
/* Prior to GCC 4.8, "Q" will be expanded to [rx, #0] which is not
|
||||
accepted by assembler. So has to use following less efficient pattern.
|
||||
*/
|
||||
__ASM volatile ("ldrht %0, [%1]" : "=r" (result) : "r" (ptr) : "memory" );
|
||||
#endif
|
||||
return ((uint16_t) result); /* Add explicit type cast here */
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief LDRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged LDRT instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDRT(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldrt %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (8 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRBT(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strbt %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (16 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRHT(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strht %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief STRT Unprivileged (32 bit)
|
||||
\details Executes a Unprivileged STRT instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STRT(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
__ASM volatile ("strt %1, %0" : "=Q" (*ptr) : "r" (value) );
|
||||
}
|
||||
|
||||
#else /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
/**
|
||||
\brief Signed Saturate
|
||||
\details Saturates a signed value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (1..32)
|
||||
\return Saturated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if ((sat >= 1U) && (sat <= 32U))
|
||||
{
|
||||
const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
|
||||
const int32_t min = -1 - max ;
|
||||
if (val > max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < min)
|
||||
{
|
||||
return min;
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
/**
|
||||
\brief Unsigned Saturate
|
||||
\details Saturates an unsigned value.
|
||||
\param [in] value Value to be saturated
|
||||
\param [in] sat Bit position to saturate to (0..31)
|
||||
\return Saturated value
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if (sat <= 31U)
|
||||
{
|
||||
const uint32_t max = ((1U << sat) - 1U);
|
||||
if (val > (int32_t)max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < 0)
|
||||
{
|
||||
return 0U;
|
||||
}
|
||||
}
|
||||
return (uint32_t)val;
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_7M__ ) && (__ARM_ARCH_7M__ == 1)) || \
|
||||
(defined (__ARM_ARCH_7EM__ ) && (__ARM_ARCH_7EM__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) ) */
|
||||
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
/**
|
||||
\brief Load-Acquire (8 bit)
|
||||
\details Executes a LDAB instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDAB(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldab %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint8_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire (16 bit)
|
||||
\details Executes a LDAH instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDAH(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldah %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint16_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire (32 bit)
|
||||
\details Executes a LDA instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDA(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("lda %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (8 bit)
|
||||
\details Executes a STLB instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STLB(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stlb %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (16 bit)
|
||||
\details Executes a STLH instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STLH(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stlh %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release (32 bit)
|
||||
\details Executes a STL instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
*/
|
||||
__STATIC_FORCEINLINE void __STL(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
__ASM volatile ("stl %1, %0" : "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (8 bit)
|
||||
\details Executes a LDAB exclusive instruction for 8 bit value.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint8_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint8_t __LDAEXB(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldaexb %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint8_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (16 bit)
|
||||
\details Executes a LDAH exclusive instruction for 16 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint16_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint16_t __LDAEXH(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldaexh %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return ((uint16_t) result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Load-Acquire Exclusive (32 bit)
|
||||
\details Executes a LDA exclusive instruction for 32 bit values.
|
||||
\param [in] ptr Pointer to data
|
||||
\return value of type uint32_t at (*ptr)
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __LDAEX(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ldaex %0, %1" : "=r" (result) : "Q" (*ptr) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (8 bit)
|
||||
\details Executes a STLB exclusive instruction for 8 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("stlexb %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (16 bit)
|
||||
\details Executes a STLH exclusive instruction for 16 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("stlexh %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Store-Release Exclusive (32 bit)
|
||||
\details Executes a STL exclusive instruction for 32 bit values.
|
||||
\param [in] value Value to store
|
||||
\param [in] ptr Pointer to location
|
||||
\return 0 Function succeeded
|
||||
\return 1 Function failed
|
||||
*/
|
||||
__STATIC_FORCEINLINE uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("stlex %0, %2, %1" : "=&r" (result), "=Q" (*ptr) : "r" ((uint32_t)value) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#endif /* ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) ) */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_Core_InstructionInterface */
|
||||
|
||||
|
||||
/* ################### Compiler specific Intrinsics ########################### */
|
||||
/** \defgroup CMSIS_SIMD_intrinsics CMSIS SIMD Intrinsics
|
||||
Access to dedicated SIMD instructions
|
||||
@{
|
||||
*/
|
||||
|
||||
#if (__ARM_FEATURE_DSP == 1) /* ToDo ARMCLANG: This should be ARCH >= ARMv7-M + SIMD */
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHADD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhadd8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSUB8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsub8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHADD16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhadd16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSUB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsub16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHASX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhasx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("ssax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __QSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("qsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SHSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("shsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UQSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uqsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UHSAX(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uhsax %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USAD8(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usad8 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __USADA8(uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("usada8 %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#define __SSAT16(ARG1,ARG2) \
|
||||
({ \
|
||||
int32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("ssat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
#define __USAT16(ARG1,ARG2) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1); \
|
||||
__ASM ("usat16 %0, %1, %2" : "=r" (__RES) : "I" (ARG2), "r" (__ARG1) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UXTB16(uint32_t op1)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uxtb16 %0, %1" : "=r" (result) : "r" (op1));
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __UXTAB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("uxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SXTB16(uint32_t op1)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sxtb16 %0, %1" : "=r" (result) : "r" (op1));
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SXTAB16(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sxtab16 %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUAD (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smuad %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUADX (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smuadx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLAD (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlad %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLADX (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smladx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLALD (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlald %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLALDX (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlaldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUSD (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smusd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMUSDX (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smusdx %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLSD (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlsd %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SMLSDX (uint32_t op1, uint32_t op2, uint32_t op3)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("smlsdx %0, %1, %2, %3" : "=r" (result) : "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLSLD (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlsld %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint64_t __SMLSLDX (uint32_t op1, uint32_t op2, uint64_t acc)
|
||||
{
|
||||
union llreg_u{
|
||||
uint32_t w32[2];
|
||||
uint64_t w64;
|
||||
} llr;
|
||||
llr.w64 = acc;
|
||||
|
||||
#ifndef __ARMEB__ /* Little endian */
|
||||
__ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[0]), "=r" (llr.w32[1]): "r" (op1), "r" (op2) , "0" (llr.w32[0]), "1" (llr.w32[1]) );
|
||||
#else /* Big endian */
|
||||
__ASM volatile ("smlsldx %0, %1, %2, %3" : "=r" (llr.w32[1]), "=r" (llr.w32[0]): "r" (op1), "r" (op2) , "0" (llr.w32[1]), "1" (llr.w32[0]) );
|
||||
#endif
|
||||
|
||||
return(llr.w64);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE uint32_t __SEL (uint32_t op1, uint32_t op2)
|
||||
{
|
||||
uint32_t result;
|
||||
|
||||
__ASM volatile ("sel %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __QADD( int32_t op1, int32_t op2)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("qadd %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __QSUB( int32_t op1, int32_t op2)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("qsub %0, %1, %2" : "=r" (result) : "r" (op1), "r" (op2) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#if 0
|
||||
#define __PKHBT(ARG1,ARG2,ARG3) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
|
||||
__ASM ("pkhbt %0, %1, %2, lsl %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \
|
||||
__RES; \
|
||||
})
|
||||
|
||||
#define __PKHTB(ARG1,ARG2,ARG3) \
|
||||
({ \
|
||||
uint32_t __RES, __ARG1 = (ARG1), __ARG2 = (ARG2); \
|
||||
if (ARG3 == 0) \
|
||||
__ASM ("pkhtb %0, %1, %2" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2) ); \
|
||||
else \
|
||||
__ASM ("pkhtb %0, %1, %2, asr %3" : "=r" (__RES) : "r" (__ARG1), "r" (__ARG2), "I" (ARG3) ); \
|
||||
__RES; \
|
||||
})
|
||||
#endif
|
||||
|
||||
#define __PKHBT(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0x0000FFFFUL) | \
|
||||
((((uint32_t)(ARG2)) << (ARG3)) & 0xFFFF0000UL) )
|
||||
|
||||
#define __PKHTB(ARG1,ARG2,ARG3) ( ((((uint32_t)(ARG1)) ) & 0xFFFF0000UL) | \
|
||||
((((uint32_t)(ARG2)) >> (ARG3)) & 0x0000FFFFUL) )
|
||||
|
||||
__STATIC_FORCEINLINE int32_t __SMMLA (int32_t op1, int32_t op2, int32_t op3)
|
||||
{
|
||||
int32_t result;
|
||||
|
||||
__ASM volatile ("smmla %0, %1, %2, %3" : "=r" (result): "r" (op1), "r" (op2), "r" (op3) );
|
||||
return(result);
|
||||
}
|
||||
|
||||
#endif /* (__ARM_FEATURE_DSP == 1) */
|
||||
/*@} end of group CMSIS_SIMD_intrinsics */
|
||||
|
||||
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
#endif /* __CMSIS_GCC_H */
|
||||
906
MDK-ARM/platform/CMSIS/Core/Include/cmsis_iccarm.h
Normal file
906
MDK-ARM/platform/CMSIS/Core/Include/cmsis_iccarm.h
Normal file
@@ -0,0 +1,906 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_iccarm.h
|
||||
* @brief CMSIS compiler ICCARM (IAR compiler) header file
|
||||
* @version V5.0.3
|
||||
* @date 29. August 2017
|
||||
******************************************************************************/
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
//
|
||||
// Copyright (c) 2017 IAR Systems
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License")
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
//
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#ifndef __CMSIS_ICCARM_H__
|
||||
#define __CMSIS_ICCARM_H__
|
||||
|
||||
#ifndef __ICCARM__
|
||||
#error This file should only be compiled by ICCARM
|
||||
#endif
|
||||
|
||||
#pragma system_include
|
||||
|
||||
#define __IAR_FT _Pragma("inline=forced") __intrinsic
|
||||
|
||||
#if (__VER__ >= 8000000)
|
||||
#define __ICCARM_V8 1
|
||||
#else
|
||||
#define __ICCARM_V8 0
|
||||
#endif
|
||||
|
||||
#ifndef __ALIGNED
|
||||
#if __ICCARM_V8
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#elif (__VER__ >= 7080000)
|
||||
/* Needs IAR language extensions */
|
||||
#define __ALIGNED(x) __attribute__((aligned(x)))
|
||||
#else
|
||||
#warning No compiler specific solution for __ALIGNED.__ALIGNED is ignored.
|
||||
#define __ALIGNED(x)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/* Define compiler macros for CPU architecture, used in CMSIS 5.
|
||||
*/
|
||||
#if __ARM_ARCH_6M__ || __ARM_ARCH_7M__ || __ARM_ARCH_7EM__ || __ARM_ARCH_8M_BASE__ || __ARM_ARCH_8M_MAIN__
|
||||
/* Macros already defined */
|
||||
#else
|
||||
#if defined(__ARM8M_MAINLINE__) || defined(__ARM8EM_MAINLINE__)
|
||||
#define __ARM_ARCH_8M_MAIN__ 1
|
||||
#elif defined(__ARM8M_BASELINE__)
|
||||
#define __ARM_ARCH_8M_BASE__ 1
|
||||
#elif defined(__ARM_ARCH_PROFILE) && __ARM_ARCH_PROFILE == 'M'
|
||||
#if __ARM_ARCH == 6
|
||||
#define __ARM_ARCH_6M__ 1
|
||||
#elif __ARM_ARCH == 7
|
||||
#if __ARM_FEATURE_DSP
|
||||
#define __ARM_ARCH_7EM__ 1
|
||||
#else
|
||||
#define __ARM_ARCH_7M__ 1
|
||||
#endif
|
||||
#endif /* __ARM_ARCH */
|
||||
#endif /* __ARM_ARCH_PROFILE == 'M' */
|
||||
#endif
|
||||
|
||||
/* Alternativ core deduction for older ICCARM's */
|
||||
#if !defined(__ARM_ARCH_6M__) && !defined(__ARM_ARCH_7M__) && !defined(__ARM_ARCH_7EM__) && \
|
||||
!defined(__ARM_ARCH_8M_BASE__) && !defined(__ARM_ARCH_8M_MAIN__)
|
||||
#if defined(__ARM6M__) && (__CORE__ == __ARM6M__)
|
||||
#define __ARM_ARCH_6M__ 1
|
||||
#elif defined(__ARM7M__) && (__CORE__ == __ARM7M__)
|
||||
#define __ARM_ARCH_7M__ 1
|
||||
#elif defined(__ARM7EM__) && (__CORE__ == __ARM7EM__)
|
||||
#define __ARM_ARCH_7EM__ 1
|
||||
#elif defined(__ARM8M_BASELINE__) && (__CORE == __ARM8M_BASELINE__)
|
||||
#define __ARM_ARCH_8M_BASE__ 1
|
||||
#elif defined(__ARM8M_MAINLINE__) && (__CORE == __ARM8M_MAINLINE__)
|
||||
#define __ARM_ARCH_8M_MAIN__ 1
|
||||
#elif defined(__ARM8EM_MAINLINE__) && (__CORE == __ARM8EM_MAINLINE__)
|
||||
#define __ARM_ARCH_8M_MAIN__ 1
|
||||
#else
|
||||
#error "Unknown target."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#if defined(__ARM_ARCH_6M__) && __ARM_ARCH_6M__==1
|
||||
#define __IAR_M0_FAMILY 1
|
||||
#elif defined(__ARM_ARCH_8M_BASE__) && __ARM_ARCH_8M_BASE__==1
|
||||
#define __IAR_M0_FAMILY 1
|
||||
#else
|
||||
#define __IAR_M0_FAMILY 0
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __ASM
|
||||
#define __ASM __asm
|
||||
#endif
|
||||
|
||||
#ifndef __INLINE
|
||||
#define __INLINE inline
|
||||
#endif
|
||||
|
||||
#ifndef __NO_RETURN
|
||||
#if __ICCARM_V8
|
||||
#define __NO_RETURN __attribute__((__noreturn__))
|
||||
#else
|
||||
#define __NO_RETURN _Pragma("object_attribute=__noreturn")
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __PACKED
|
||||
#if __ICCARM_V8
|
||||
#define __PACKED __attribute__((packed, aligned(1)))
|
||||
#else
|
||||
/* Needs IAR language extensions */
|
||||
#define __PACKED __packed
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __PACKED_STRUCT
|
||||
#if __ICCARM_V8
|
||||
#define __PACKED_STRUCT struct __attribute__((packed, aligned(1)))
|
||||
#else
|
||||
/* Needs IAR language extensions */
|
||||
#define __PACKED_STRUCT __packed struct
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __PACKED_UNION
|
||||
#if __ICCARM_V8
|
||||
#define __PACKED_UNION union __attribute__((packed, aligned(1)))
|
||||
#else
|
||||
/* Needs IAR language extensions */
|
||||
#define __PACKED_UNION __packed union
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __RESTRICT
|
||||
#define __RESTRICT restrict
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __STATIC_INLINE
|
||||
#define __STATIC_INLINE static inline
|
||||
#endif
|
||||
|
||||
#ifndef __UNALIGNED_UINT16_READ
|
||||
#pragma language=save
|
||||
#pragma language=extended
|
||||
__IAR_FT uint16_t __iar_uint16_read(void const *ptr)
|
||||
{
|
||||
return *(__packed uint16_t*)(ptr);
|
||||
}
|
||||
#pragma language=restore
|
||||
#define __UNALIGNED_UINT16_READ(PTR) __iar_uint16_read(PTR)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __UNALIGNED_UINT16_WRITE
|
||||
#pragma language=save
|
||||
#pragma language=extended
|
||||
__IAR_FT void __iar_uint16_write(void const *ptr, uint16_t val)
|
||||
{
|
||||
*(__packed uint16_t*)(ptr) = val;;
|
||||
}
|
||||
#pragma language=restore
|
||||
#define __UNALIGNED_UINT16_WRITE(PTR,VAL) __iar_uint16_write(PTR,VAL)
|
||||
#endif
|
||||
|
||||
#ifndef __UNALIGNED_UINT32_READ
|
||||
#pragma language=save
|
||||
#pragma language=extended
|
||||
__IAR_FT uint32_t __iar_uint32_read(void const *ptr)
|
||||
{
|
||||
return *(__packed uint32_t*)(ptr);
|
||||
}
|
||||
#pragma language=restore
|
||||
#define __UNALIGNED_UINT32_READ(PTR) __iar_uint32_read(PTR)
|
||||
#endif
|
||||
|
||||
#ifndef __UNALIGNED_UINT32_WRITE
|
||||
#pragma language=save
|
||||
#pragma language=extended
|
||||
__IAR_FT void __iar_uint32_write(void const *ptr, uint32_t val)
|
||||
{
|
||||
*(__packed uint32_t*)(ptr) = val;;
|
||||
}
|
||||
#pragma language=restore
|
||||
#define __UNALIGNED_UINT32_WRITE(PTR,VAL) __iar_uint32_write(PTR,VAL)
|
||||
#endif
|
||||
|
||||
#ifndef __UNALIGNED_UINT32 /* deprecated */
|
||||
#pragma language=save
|
||||
#pragma language=extended
|
||||
__packed struct __iar_u32 { uint32_t v; };
|
||||
#pragma language=restore
|
||||
#define __UNALIGNED_UINT32(PTR) (((struct __iar_u32 *)(PTR))->v)
|
||||
#endif
|
||||
|
||||
#ifndef __USED
|
||||
#if __ICCARM_V8
|
||||
#define __USED __attribute__((used))
|
||||
#else
|
||||
#define __USED _Pragma("__root")
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef __WEAK
|
||||
#if __ICCARM_V8
|
||||
#define __WEAK __attribute__((weak))
|
||||
#else
|
||||
#define __WEAK _Pragma("__weak")
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __ICCARM_INTRINSICS_VERSION__
|
||||
#define __ICCARM_INTRINSICS_VERSION__ 0
|
||||
#endif
|
||||
|
||||
#if __ICCARM_INTRINSICS_VERSION__ == 2
|
||||
|
||||
#if defined(__CLZ)
|
||||
#undef __CLZ
|
||||
#endif
|
||||
#if defined(__REVSH)
|
||||
#undef __REVSH
|
||||
#endif
|
||||
#if defined(__RBIT)
|
||||
#undef __RBIT
|
||||
#endif
|
||||
#if defined(__SSAT)
|
||||
#undef __SSAT
|
||||
#endif
|
||||
#if defined(__USAT)
|
||||
#undef __USAT
|
||||
#endif
|
||||
|
||||
#include "iccarm_builtin.h"
|
||||
|
||||
#define __disable_fault_irq __iar_builtin_disable_fiq
|
||||
#define __disable_irq __iar_builtin_disable_interrupt
|
||||
#define __enable_fault_irq __iar_builtin_enable_fiq
|
||||
#define __enable_irq __iar_builtin_enable_interrupt
|
||||
#define __arm_rsr __iar_builtin_rsr
|
||||
#define __arm_wsr __iar_builtin_wsr
|
||||
|
||||
|
||||
#define __get_APSR() (__arm_rsr("APSR"))
|
||||
#define __get_BASEPRI() (__arm_rsr("BASEPRI"))
|
||||
#define __get_CONTROL() (__arm_rsr("CONTROL"))
|
||||
#define __get_FAULTMASK() (__arm_rsr("FAULTMASK"))
|
||||
|
||||
#if ((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) )
|
||||
#define __get_FPSCR() (__arm_rsr("FPSCR"))
|
||||
#define __set_FPSCR(VALUE) (__arm_wsr("FPSCR", (VALUE)))
|
||||
#else
|
||||
#define __get_FPSCR() ( 0 )
|
||||
#define __set_FPSCR(VALUE) ((void)VALUE)
|
||||
#endif
|
||||
|
||||
#define __get_IPSR() (__arm_rsr("IPSR"))
|
||||
#define __get_MSP() (__arm_rsr("MSP"))
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure MSPLIM is RAZ/WI
|
||||
#define __get_MSPLIM() (0U)
|
||||
#else
|
||||
#define __get_MSPLIM() (__arm_rsr("MSPLIM"))
|
||||
#endif
|
||||
#define __get_PRIMASK() (__arm_rsr("PRIMASK"))
|
||||
#define __get_PSP() (__arm_rsr("PSP"))
|
||||
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure PSPLIM is RAZ/WI
|
||||
#define __get_PSPLIM() (0U)
|
||||
#else
|
||||
#define __get_PSPLIM() (__arm_rsr("PSPLIM"))
|
||||
#endif
|
||||
|
||||
#define __get_xPSR() (__arm_rsr("xPSR"))
|
||||
|
||||
#define __set_BASEPRI(VALUE) (__arm_wsr("BASEPRI", (VALUE)))
|
||||
#define __set_BASEPRI_MAX(VALUE) (__arm_wsr("BASEPRI_MAX", (VALUE)))
|
||||
#define __set_CONTROL(VALUE) (__arm_wsr("CONTROL", (VALUE)))
|
||||
#define __set_FAULTMASK(VALUE) (__arm_wsr("FAULTMASK", (VALUE)))
|
||||
#define __set_MSP(VALUE) (__arm_wsr("MSP", (VALUE)))
|
||||
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure MSPLIM is RAZ/WI
|
||||
#define __set_MSPLIM(VALUE) ((void)(VALUE))
|
||||
#else
|
||||
#define __set_MSPLIM(VALUE) (__arm_wsr("MSPLIM", (VALUE)))
|
||||
#endif
|
||||
#define __set_PRIMASK(VALUE) (__arm_wsr("PRIMASK", (VALUE)))
|
||||
#define __set_PSP(VALUE) (__arm_wsr("PSP", (VALUE)))
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure PSPLIM is RAZ/WI
|
||||
#define __set_PSPLIM(VALUE) ((void)(VALUE))
|
||||
#else
|
||||
#define __set_PSPLIM(VALUE) (__arm_wsr("PSPLIM", (VALUE)))
|
||||
#endif
|
||||
|
||||
#define __TZ_get_CONTROL_NS() (__arm_rsr("CONTROL_NS"))
|
||||
#define __TZ_set_CONTROL_NS(VALUE) (__arm_wsr("CONTROL_NS", (VALUE)))
|
||||
#define __TZ_get_PSP_NS() (__arm_rsr("PSP_NS"))
|
||||
#define __TZ_set_PSP_NS(VALUE) (__arm_wsr("PSP_NS", (VALUE)))
|
||||
#define __TZ_get_MSP_NS() (__arm_rsr("MSP_NS"))
|
||||
#define __TZ_set_MSP_NS(VALUE) (__arm_wsr("MSP_NS", (VALUE)))
|
||||
#define __TZ_get_SP_NS() (__arm_rsr("SP_NS"))
|
||||
#define __TZ_set_SP_NS(VALUE) (__arm_wsr("SP_NS", (VALUE)))
|
||||
#define __TZ_get_PRIMASK_NS() (__arm_rsr("PRIMASK_NS"))
|
||||
#define __TZ_set_PRIMASK_NS(VALUE) (__arm_wsr("PRIMASK_NS", (VALUE)))
|
||||
#define __TZ_get_BASEPRI_NS() (__arm_rsr("BASEPRI_NS"))
|
||||
#define __TZ_set_BASEPRI_NS(VALUE) (__arm_wsr("BASEPRI_NS", (VALUE)))
|
||||
#define __TZ_get_FAULTMASK_NS() (__arm_rsr("FAULTMASK_NS"))
|
||||
#define __TZ_set_FAULTMASK_NS(VALUE)(__arm_wsr("FAULTMASK_NS", (VALUE)))
|
||||
#define __TZ_get_PSPLIM_NS() (__arm_rsr("PSPLIM_NS"))
|
||||
#define __TZ_set_PSPLIM_NS(VALUE) (__arm_wsr("PSPLIM_NS", (VALUE)))
|
||||
#define __TZ_get_MSPLIM_NS() (__arm_rsr("MSPLIM_NS"))
|
||||
#define __TZ_set_MSPLIM_NS(VALUE) (__arm_wsr("MSPLIM_NS", (VALUE)))
|
||||
|
||||
#define __NOP __iar_builtin_no_operation
|
||||
|
||||
#define __CLZ __iar_builtin_CLZ
|
||||
#define __CLREX __iar_builtin_CLREX
|
||||
|
||||
#define __DMB __iar_builtin_DMB
|
||||
#define __DSB __iar_builtin_DSB
|
||||
#define __ISB __iar_builtin_ISB
|
||||
|
||||
#define __LDREXB __iar_builtin_LDREXB
|
||||
#define __LDREXH __iar_builtin_LDREXH
|
||||
#define __LDREXW __iar_builtin_LDREX
|
||||
|
||||
#define __RBIT __iar_builtin_RBIT
|
||||
#define __REV __iar_builtin_REV
|
||||
#define __REV16 __iar_builtin_REV16
|
||||
|
||||
__IAR_FT int16_t __REVSH(int16_t val)
|
||||
{
|
||||
return (int16_t) __iar_builtin_REVSH(val);
|
||||
}
|
||||
|
||||
#define __ROR __iar_builtin_ROR
|
||||
#define __RRX __iar_builtin_RRX
|
||||
|
||||
#define __SEV __iar_builtin_SEV
|
||||
|
||||
#if !__IAR_M0_FAMILY
|
||||
#define __SSAT __iar_builtin_SSAT
|
||||
#endif
|
||||
|
||||
#define __STREXB __iar_builtin_STREXB
|
||||
#define __STREXH __iar_builtin_STREXH
|
||||
#define __STREXW __iar_builtin_STREX
|
||||
|
||||
#if !__IAR_M0_FAMILY
|
||||
#define __USAT __iar_builtin_USAT
|
||||
#endif
|
||||
|
||||
#define __WFE __iar_builtin_WFE
|
||||
#define __WFI __iar_builtin_WFI
|
||||
|
||||
#if __ARM_MEDIA__
|
||||
#define __SADD8 __iar_builtin_SADD8
|
||||
#define __QADD8 __iar_builtin_QADD8
|
||||
#define __SHADD8 __iar_builtin_SHADD8
|
||||
#define __UADD8 __iar_builtin_UADD8
|
||||
#define __UQADD8 __iar_builtin_UQADD8
|
||||
#define __UHADD8 __iar_builtin_UHADD8
|
||||
#define __SSUB8 __iar_builtin_SSUB8
|
||||
#define __QSUB8 __iar_builtin_QSUB8
|
||||
#define __SHSUB8 __iar_builtin_SHSUB8
|
||||
#define __USUB8 __iar_builtin_USUB8
|
||||
#define __UQSUB8 __iar_builtin_UQSUB8
|
||||
#define __UHSUB8 __iar_builtin_UHSUB8
|
||||
#define __SADD16 __iar_builtin_SADD16
|
||||
#define __QADD16 __iar_builtin_QADD16
|
||||
#define __SHADD16 __iar_builtin_SHADD16
|
||||
#define __UADD16 __iar_builtin_UADD16
|
||||
#define __UQADD16 __iar_builtin_UQADD16
|
||||
#define __UHADD16 __iar_builtin_UHADD16
|
||||
#define __SSUB16 __iar_builtin_SSUB16
|
||||
#define __QSUB16 __iar_builtin_QSUB16
|
||||
#define __SHSUB16 __iar_builtin_SHSUB16
|
||||
#define __USUB16 __iar_builtin_USUB16
|
||||
#define __UQSUB16 __iar_builtin_UQSUB16
|
||||
#define __UHSUB16 __iar_builtin_UHSUB16
|
||||
#define __SASX __iar_builtin_SASX
|
||||
#define __QASX __iar_builtin_QASX
|
||||
#define __SHASX __iar_builtin_SHASX
|
||||
#define __UASX __iar_builtin_UASX
|
||||
#define __UQASX __iar_builtin_UQASX
|
||||
#define __UHASX __iar_builtin_UHASX
|
||||
#define __SSAX __iar_builtin_SSAX
|
||||
#define __QSAX __iar_builtin_QSAX
|
||||
#define __SHSAX __iar_builtin_SHSAX
|
||||
#define __USAX __iar_builtin_USAX
|
||||
#define __UQSAX __iar_builtin_UQSAX
|
||||
#define __UHSAX __iar_builtin_UHSAX
|
||||
#define __USAD8 __iar_builtin_USAD8
|
||||
#define __USADA8 __iar_builtin_USADA8
|
||||
#define __SSAT16 __iar_builtin_SSAT16
|
||||
#define __USAT16 __iar_builtin_USAT16
|
||||
#define __UXTB16 __iar_builtin_UXTB16
|
||||
#define __UXTAB16 __iar_builtin_UXTAB16
|
||||
#define __SXTB16 __iar_builtin_SXTB16
|
||||
#define __SXTAB16 __iar_builtin_SXTAB16
|
||||
#define __SMUAD __iar_builtin_SMUAD
|
||||
#define __SMUADX __iar_builtin_SMUADX
|
||||
#define __SMMLA __iar_builtin_SMMLA
|
||||
#define __SMLAD __iar_builtin_SMLAD
|
||||
#define __SMLADX __iar_builtin_SMLADX
|
||||
#define __SMLALD __iar_builtin_SMLALD
|
||||
#define __SMLALDX __iar_builtin_SMLALDX
|
||||
#define __SMUSD __iar_builtin_SMUSD
|
||||
#define __SMUSDX __iar_builtin_SMUSDX
|
||||
#define __SMLSD __iar_builtin_SMLSD
|
||||
#define __SMLSDX __iar_builtin_SMLSDX
|
||||
#define __SMLSLD __iar_builtin_SMLSLD
|
||||
#define __SMLSLDX __iar_builtin_SMLSLDX
|
||||
#define __SEL __iar_builtin_SEL
|
||||
#define __QADD __iar_builtin_QADD
|
||||
#define __QSUB __iar_builtin_QSUB
|
||||
#define __PKHBT __iar_builtin_PKHBT
|
||||
#define __PKHTB __iar_builtin_PKHTB
|
||||
#endif
|
||||
|
||||
#else /* __ICCARM_INTRINSICS_VERSION__ == 2 */
|
||||
|
||||
#if __IAR_M0_FAMILY
|
||||
/* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */
|
||||
#define __CLZ __cmsis_iar_clz_not_active
|
||||
#define __SSAT __cmsis_iar_ssat_not_active
|
||||
#define __USAT __cmsis_iar_usat_not_active
|
||||
#define __RBIT __cmsis_iar_rbit_not_active
|
||||
#define __get_APSR __cmsis_iar_get_APSR_not_active
|
||||
#endif
|
||||
|
||||
|
||||
#if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) ))
|
||||
#define __get_FPSCR __cmsis_iar_get_FPSR_not_active
|
||||
#define __set_FPSCR __cmsis_iar_set_FPSR_not_active
|
||||
#endif
|
||||
|
||||
#ifdef __INTRINSICS_INCLUDED
|
||||
#error intrinsics.h is already included previously!
|
||||
#endif
|
||||
|
||||
#include <intrinsics.h>
|
||||
|
||||
#if __IAR_M0_FAMILY
|
||||
/* Avoid clash between intrinsics.h and arm_math.h when compiling for Cortex-M0. */
|
||||
#undef __CLZ
|
||||
#undef __SSAT
|
||||
#undef __USAT
|
||||
#undef __RBIT
|
||||
#undef __get_APSR
|
||||
|
||||
__STATIC_INLINE uint8_t __CLZ(uint32_t data)
|
||||
{
|
||||
if (data == 0U) { return 32U; }
|
||||
|
||||
uint32_t count = 0U;
|
||||
uint32_t mask = 0x80000000U;
|
||||
|
||||
while ((data & mask) == 0U)
|
||||
{
|
||||
count += 1U;
|
||||
mask = mask >> 1U;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
__STATIC_INLINE uint32_t __RBIT(uint32_t v)
|
||||
{
|
||||
uint8_t sc = 31U;
|
||||
uint32_t r = v;
|
||||
for (v >>= 1U; v; v >>= 1U)
|
||||
{
|
||||
r <<= 1U;
|
||||
r |= v & 1U;
|
||||
sc--;
|
||||
}
|
||||
return (r << sc);
|
||||
}
|
||||
|
||||
__STATIC_INLINE uint32_t __get_APSR(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm("MRS %0,APSR" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#if (!((defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)) && \
|
||||
(defined (__FPU_USED ) && (__FPU_USED == 1U)) ))
|
||||
#undef __get_FPSCR
|
||||
#undef __set_FPSCR
|
||||
#define __get_FPSCR() (0)
|
||||
#define __set_FPSCR(VALUE) ((void)VALUE)
|
||||
#endif
|
||||
|
||||
#pragma diag_suppress=Pe940
|
||||
#pragma diag_suppress=Pe177
|
||||
|
||||
#define __enable_irq __enable_interrupt
|
||||
#define __disable_irq __disable_interrupt
|
||||
#define __NOP __no_operation
|
||||
|
||||
#define __get_xPSR __get_PSR
|
||||
|
||||
#if (!defined(__ARM_ARCH_6M__) || __ARM_ARCH_6M__==0)
|
||||
|
||||
__IAR_FT uint32_t __LDREXW(uint32_t volatile *ptr)
|
||||
{
|
||||
return __LDREX((unsigned long *)ptr);
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __STREXW(uint32_t value, uint32_t volatile *ptr)
|
||||
{
|
||||
return __STREX(value, (unsigned long *)ptr);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */
|
||||
#if (__CORTEX_M >= 0x03)
|
||||
|
||||
__IAR_FT uint32_t __RRX(uint32_t value)
|
||||
{
|
||||
uint32_t result;
|
||||
__ASM("RRX %0, %1" : "=r"(result) : "r" (value) : "cc");
|
||||
return(result);
|
||||
}
|
||||
|
||||
__IAR_FT void __set_BASEPRI_MAX(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR BASEPRI_MAX,%0"::"r" (value));
|
||||
}
|
||||
|
||||
|
||||
#define __enable_fault_irq __enable_fiq
|
||||
#define __disable_fault_irq __disable_fiq
|
||||
|
||||
|
||||
#endif /* (__CORTEX_M >= 0x03) */
|
||||
|
||||
__IAR_FT uint32_t __ROR(uint32_t op1, uint32_t op2)
|
||||
{
|
||||
return (op1 >> op2) | (op1 << ((sizeof(op1)*8)-op2));
|
||||
}
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
|
||||
__IAR_FT uint32_t __get_MSPLIM(void)
|
||||
{
|
||||
uint32_t res;
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure MSPLIM is RAZ/WI
|
||||
res = 0U;
|
||||
#else
|
||||
__asm volatile("MRS %0,MSPLIM" : "=r" (res));
|
||||
#endif
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __set_MSPLIM(uint32_t value)
|
||||
{
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure MSPLIM is RAZ/WI
|
||||
(void)value;
|
||||
#else
|
||||
__asm volatile("MSR MSPLIM,%0" :: "r" (value));
|
||||
#endif
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __get_PSPLIM(void)
|
||||
{
|
||||
uint32_t res;
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure PSPLIM is RAZ/WI
|
||||
res = 0U;
|
||||
#else
|
||||
__asm volatile("MRS %0,PSPLIM" : "=r" (res));
|
||||
#endif
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __set_PSPLIM(uint32_t value)
|
||||
{
|
||||
#if (!(defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) && \
|
||||
(!defined (__ARM_FEATURE_CMSE ) || (__ARM_FEATURE_CMSE < 3)))
|
||||
// without main extensions, the non-secure PSPLIM is RAZ/WI
|
||||
(void)value;
|
||||
#else
|
||||
__asm volatile("MSR PSPLIM,%0" :: "r" (value));
|
||||
#endif
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_CONTROL_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,CONTROL_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_CONTROL_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR CONTROL_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_PSP_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,PSP_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_PSP_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR PSP_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_MSP_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,MSP_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_MSP_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR MSP_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_SP_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,SP_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
__IAR_FT void __TZ_set_SP_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR SP_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_PRIMASK_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,PRIMASK_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_PRIMASK_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR PRIMASK_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_BASEPRI_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,BASEPRI_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_BASEPRI_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR BASEPRI_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_FAULTMASK_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,FAULTMASK_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_FAULTMASK_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR FAULTMASK_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_PSPLIM_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,PSPLIM_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
__IAR_FT void __TZ_set_PSPLIM_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR PSPLIM_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __TZ_get_MSPLIM_NS(void)
|
||||
{
|
||||
uint32_t res;
|
||||
__asm volatile("MRS %0,MSPLIM_NS" : "=r" (res));
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __TZ_set_MSPLIM_NS(uint32_t value)
|
||||
{
|
||||
__asm volatile("MSR MSPLIM_NS,%0" :: "r" (value));
|
||||
}
|
||||
|
||||
#endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */
|
||||
|
||||
#endif /* __ICCARM_INTRINSICS_VERSION__ == 2 */
|
||||
|
||||
#define __BKPT(value) __asm volatile ("BKPT %0" : : "i"(value))
|
||||
|
||||
#if __IAR_M0_FAMILY
|
||||
__STATIC_INLINE int32_t __SSAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if ((sat >= 1U) && (sat <= 32U))
|
||||
{
|
||||
const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
|
||||
const int32_t min = -1 - max ;
|
||||
if (val > max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < min)
|
||||
{
|
||||
return min;
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
__STATIC_INLINE uint32_t __USAT(int32_t val, uint32_t sat)
|
||||
{
|
||||
if (sat <= 31U)
|
||||
{
|
||||
const uint32_t max = ((1U << sat) - 1U);
|
||||
if (val > (int32_t)max)
|
||||
{
|
||||
return max;
|
||||
}
|
||||
else if (val < 0)
|
||||
{
|
||||
return 0U;
|
||||
}
|
||||
}
|
||||
return (uint32_t)val;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if (__CORTEX_M >= 0x03) /* __CORTEX_M is defined in core_cm0.h, core_cm3.h and core_cm4.h. */
|
||||
|
||||
__IAR_FT uint8_t __LDRBT(volatile uint8_t *addr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM("LDRBT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
|
||||
return ((uint8_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint16_t __LDRHT(volatile uint16_t *addr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM("LDRHT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
|
||||
return ((uint16_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __LDRT(volatile uint32_t *addr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM("LDRT %0, [%1]" : "=r" (res) : "r" (addr) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __STRBT(uint8_t value, volatile uint8_t *addr)
|
||||
{
|
||||
__ASM("STRBT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
|
||||
}
|
||||
|
||||
__IAR_FT void __STRHT(uint16_t value, volatile uint16_t *addr)
|
||||
{
|
||||
__ASM("STRHT %1, [%0]" : : "r" (addr), "r" ((uint32_t)value) : "memory");
|
||||
}
|
||||
|
||||
__IAR_FT void __STRT(uint32_t value, volatile uint32_t *addr)
|
||||
{
|
||||
__ASM("STRT %1, [%0]" : : "r" (addr), "r" (value) : "memory");
|
||||
}
|
||||
|
||||
#endif /* (__CORTEX_M >= 0x03) */
|
||||
|
||||
#if ((defined (__ARM_ARCH_8M_MAIN__ ) && (__ARM_ARCH_8M_MAIN__ == 1)) || \
|
||||
(defined (__ARM_ARCH_8M_BASE__ ) && (__ARM_ARCH_8M_BASE__ == 1)) )
|
||||
|
||||
|
||||
__IAR_FT uint8_t __LDAB(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDAB %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return ((uint8_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint16_t __LDAH(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDAH %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return ((uint16_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __LDA(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDA %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT void __STLB(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
__ASM volatile ("STLB %1, [%0]" :: "r" (*ptr), "r" (value) : "memory");
|
||||
}
|
||||
|
||||
__IAR_FT void __STLH(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
__ASM volatile ("STLH %1, [%0]" :: "r" (*ptr), "r" (value) : "memory");
|
||||
}
|
||||
|
||||
__IAR_FT void __STL(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
__ASM volatile ("STL %1, [%0]" :: "r" (*ptr), "r" (value) : "memory");
|
||||
}
|
||||
|
||||
__IAR_FT uint8_t __LDAEXB(volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDAEXB %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return ((uint8_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint16_t __LDAEXH(volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDAEXH %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return ((uint16_t)res);
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __LDAEX(volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("LDAEX %0, [%1]" : "=r" (res) : "r" (*ptr) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __STLEXB(uint8_t value, volatile uint8_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("STLEXB %0, %2, [%1]" : "=r" (res) : "r" (*ptr), "r" (value) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __STLEXH(uint16_t value, volatile uint16_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("STLEXH %0, %2, [%1]" : "=r" (res) : "r" (*ptr), "r" (value) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
__IAR_FT uint32_t __STLEX(uint32_t value, volatile uint32_t *ptr)
|
||||
{
|
||||
uint32_t res;
|
||||
__ASM volatile ("STLEX %0, %2, [%1]" : "=r" (res) : "r" (*ptr), "r" (value) : "memory");
|
||||
return res;
|
||||
}
|
||||
|
||||
#endif /* __ARM_ARCH_8M_MAIN__ or __ARM_ARCH_8M_BASE__ */
|
||||
|
||||
#undef __IAR_FT
|
||||
#undef __IAR_M0_FAMILY
|
||||
#undef __ICCARM_V8
|
||||
|
||||
#pragma diag_default=Pe940
|
||||
#pragma diag_default=Pe177
|
||||
|
||||
#endif /* __CMSIS_ICCARM_H__ */
|
||||
39
MDK-ARM/platform/CMSIS/Core/Include/cmsis_version.h
Normal file
39
MDK-ARM/platform/CMSIS/Core/Include/cmsis_version.h
Normal file
@@ -0,0 +1,39 @@
|
||||
/**************************************************************************//**
|
||||
* @file cmsis_version.h
|
||||
* @brief CMSIS Core(M) Version definitions
|
||||
* @version V5.0.2
|
||||
* @date 19. April 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#if defined ( __ICCARM__ )
|
||||
#pragma system_include /* treat file as system include file for MISRA check */
|
||||
#elif defined (__clang__)
|
||||
#pragma clang system_header /* treat file as system include file */
|
||||
#endif
|
||||
|
||||
#ifndef __CMSIS_VERSION_H
|
||||
#define __CMSIS_VERSION_H
|
||||
|
||||
/* CMSIS Version definitions */
|
||||
#define __CM_CMSIS_VERSION_MAIN ( 5U) /*!< [31:16] CMSIS Core(M) main version */
|
||||
#define __CM_CMSIS_VERSION_SUB ( 1U) /*!< [15:0] CMSIS Core(M) sub version */
|
||||
#define __CM_CMSIS_VERSION ((__CM_CMSIS_VERSION_MAIN << 16U) | \
|
||||
__CM_CMSIS_VERSION_SUB ) /*!< CMSIS Core(M) version number */
|
||||
#endif
|
||||
2115
MDK-ARM/platform/CMSIS/Core/Include/core_cm4.h
Normal file
2115
MDK-ARM/platform/CMSIS/Core/Include/core_cm4.h
Normal file
@@ -0,0 +1,2115 @@
|
||||
/**************************************************************************//**
|
||||
* @file core_cm4.h
|
||||
* @brief CMSIS Cortex-M4 Core Peripheral Access Layer Header File
|
||||
* @version V5.0.3
|
||||
* @date 09. August 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2009-2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#if defined ( __ICCARM__ )
|
||||
#pragma system_include /* treat file as system include file for MISRA check */
|
||||
#elif defined (__clang__)
|
||||
#pragma clang system_header /* treat file as system include file */
|
||||
#endif
|
||||
|
||||
#ifndef __CORE_CM4_H_GENERIC
|
||||
#define __CORE_CM4_H_GENERIC
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
\page CMSIS_MISRA_Exceptions MISRA-C:2004 Compliance Exceptions
|
||||
CMSIS violates the following MISRA-C:2004 rules:
|
||||
|
||||
\li Required Rule 8.5, object/function definition in header file.<br>
|
||||
Function definitions in header files are used to allow 'inlining'.
|
||||
|
||||
\li Required Rule 18.4, declaration of union type or object of union type: '{...}'.<br>
|
||||
Unions are used for effective representation of core registers.
|
||||
|
||||
\li Advisory Rule 19.7, Function-like macro defined.<br>
|
||||
Function-like macros are used to allow more efficient code.
|
||||
*/
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* CMSIS definitions
|
||||
******************************************************************************/
|
||||
/**
|
||||
\ingroup Cortex_M4
|
||||
@{
|
||||
*/
|
||||
|
||||
#include "cmsis_version.h"
|
||||
|
||||
/* CMSIS CM4 definitions */
|
||||
#define __CM4_CMSIS_VERSION_MAIN (__CM_CMSIS_VERSION_MAIN) /*!< \deprecated [31:16] CMSIS HAL main version */
|
||||
#define __CM4_CMSIS_VERSION_SUB (__CM_CMSIS_VERSION_SUB) /*!< \deprecated [15:0] CMSIS HAL sub version */
|
||||
#define __CM4_CMSIS_VERSION ((__CM4_CMSIS_VERSION_MAIN << 16U) | \
|
||||
__CM4_CMSIS_VERSION_SUB ) /*!< \deprecated CMSIS HAL version number */
|
||||
|
||||
#define __CORTEX_M (4U) /*!< Cortex-M Core */
|
||||
|
||||
/** __FPU_USED indicates whether an FPU is used or not.
|
||||
For this, __FPU_PRESENT has to be checked prior to making use of FPU specific registers and functions.
|
||||
*/
|
||||
#if defined ( __CC_ARM )
|
||||
#if defined __TARGET_FPU_VFP
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6010050)
|
||||
#if defined __ARM_PCS_VFP
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#warning "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined ( __GNUC__ )
|
||||
#if defined (__VFP_FP__) && !defined(__SOFTFP__)
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined ( __ICCARM__ )
|
||||
#if defined __ARMVFP__
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined ( __TI_ARM__ )
|
||||
#if defined __TI_VFP_SUPPORT__
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined ( __TASKING__ )
|
||||
#if defined __FPU_VFP__
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#elif defined ( __CSMC__ )
|
||||
#if ( __CSMC__ & 0x400U)
|
||||
#if defined (__FPU_PRESENT) && (__FPU_PRESENT == 1U)
|
||||
#define __FPU_USED 1U
|
||||
#else
|
||||
#error "Compiler generates FPU instructions for a device without an FPU (check __FPU_PRESENT)"
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
#else
|
||||
#define __FPU_USED 0U
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#include "cmsis_compiler.h" /* CMSIS compiler specific defines */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __CORE_CM4_H_GENERIC */
|
||||
|
||||
#ifndef __CMSIS_GENERIC
|
||||
|
||||
#ifndef __CORE_CM4_H_DEPENDANT
|
||||
#define __CORE_CM4_H_DEPENDANT
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* check device defines and use defaults */
|
||||
#if defined __CHECK_DEVICE_DEFINES
|
||||
#ifndef __CM4_REV
|
||||
#define __CM4_REV 0x0000U
|
||||
#warning "__CM4_REV not defined in device header file; using default!"
|
||||
#endif
|
||||
|
||||
#ifndef __FPU_PRESENT
|
||||
#define __FPU_PRESENT 0U
|
||||
#warning "__FPU_PRESENT not defined in device header file; using default!"
|
||||
#endif
|
||||
|
||||
#ifndef __MPU_PRESENT
|
||||
#define __MPU_PRESENT 0U
|
||||
#warning "__MPU_PRESENT not defined in device header file; using default!"
|
||||
#endif
|
||||
|
||||
#ifndef __NVIC_PRIO_BITS
|
||||
#define __NVIC_PRIO_BITS 3U
|
||||
#warning "__NVIC_PRIO_BITS not defined in device header file; using default!"
|
||||
#endif
|
||||
|
||||
#ifndef __Vendor_SysTickConfig
|
||||
#define __Vendor_SysTickConfig 0U
|
||||
#warning "__Vendor_SysTickConfig not defined in device header file; using default!"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* IO definitions (access restrictions to peripheral registers) */
|
||||
/**
|
||||
\defgroup CMSIS_glob_defs CMSIS Global Defines
|
||||
|
||||
<strong>IO Type Qualifiers</strong> are used
|
||||
\li to specify the access to peripheral variables.
|
||||
\li for automatic generation of peripheral register debug information.
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
#define __I volatile /*!< Defines 'read only' permissions */
|
||||
#else
|
||||
#define __I volatile const /*!< Defines 'read only' permissions */
|
||||
#endif
|
||||
#define __O volatile /*!< Defines 'write only' permissions */
|
||||
#define __IO volatile /*!< Defines 'read / write' permissions */
|
||||
|
||||
/* following defines should be used for structure members */
|
||||
#define __IM volatile const /*! Defines 'read only' structure member permissions */
|
||||
#define __OM volatile /*! Defines 'write only' structure member permissions */
|
||||
#define __IOM volatile /*! Defines 'read / write' structure member permissions */
|
||||
|
||||
/*@} end of group Cortex_M4 */
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* Register Abstraction
|
||||
Core Register contain:
|
||||
- Core Register
|
||||
- Core NVIC Register
|
||||
- Core SCB Register
|
||||
- Core SysTick Register
|
||||
- Core Debug Register
|
||||
- Core MPU Register
|
||||
- Core FPU Register
|
||||
******************************************************************************/
|
||||
/**
|
||||
\defgroup CMSIS_core_register Defines and Type Definitions
|
||||
\brief Type definitions and defines for Cortex-M processor based devices.
|
||||
*/
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_CORE Status and Control Registers
|
||||
\brief Core Register type definitions.
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Union type to access the Application Program Status Register (APSR).
|
||||
*/
|
||||
typedef union
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint32_t _reserved0:16; /*!< bit: 0..15 Reserved */
|
||||
uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */
|
||||
uint32_t _reserved1:7; /*!< bit: 20..26 Reserved */
|
||||
uint32_t Q:1; /*!< bit: 27 Saturation condition flag */
|
||||
uint32_t V:1; /*!< bit: 28 Overflow condition code flag */
|
||||
uint32_t C:1; /*!< bit: 29 Carry condition code flag */
|
||||
uint32_t Z:1; /*!< bit: 30 Zero condition code flag */
|
||||
uint32_t N:1; /*!< bit: 31 Negative condition code flag */
|
||||
} b; /*!< Structure used for bit access */
|
||||
uint32_t w; /*!< Type used for word access */
|
||||
} APSR_Type;
|
||||
|
||||
/* APSR Register Definitions */
|
||||
#define APSR_N_Pos 31U /*!< APSR: N Position */
|
||||
#define APSR_N_Msk (1UL << APSR_N_Pos) /*!< APSR: N Mask */
|
||||
|
||||
#define APSR_Z_Pos 30U /*!< APSR: Z Position */
|
||||
#define APSR_Z_Msk (1UL << APSR_Z_Pos) /*!< APSR: Z Mask */
|
||||
|
||||
#define APSR_C_Pos 29U /*!< APSR: C Position */
|
||||
#define APSR_C_Msk (1UL << APSR_C_Pos) /*!< APSR: C Mask */
|
||||
|
||||
#define APSR_V_Pos 28U /*!< APSR: V Position */
|
||||
#define APSR_V_Msk (1UL << APSR_V_Pos) /*!< APSR: V Mask */
|
||||
|
||||
#define APSR_Q_Pos 27U /*!< APSR: Q Position */
|
||||
#define APSR_Q_Msk (1UL << APSR_Q_Pos) /*!< APSR: Q Mask */
|
||||
|
||||
#define APSR_GE_Pos 16U /*!< APSR: GE Position */
|
||||
#define APSR_GE_Msk (0xFUL << APSR_GE_Pos) /*!< APSR: GE Mask */
|
||||
|
||||
|
||||
/**
|
||||
\brief Union type to access the Interrupt Program Status Register (IPSR).
|
||||
*/
|
||||
typedef union
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */
|
||||
uint32_t _reserved0:23; /*!< bit: 9..31 Reserved */
|
||||
} b; /*!< Structure used for bit access */
|
||||
uint32_t w; /*!< Type used for word access */
|
||||
} IPSR_Type;
|
||||
|
||||
/* IPSR Register Definitions */
|
||||
#define IPSR_ISR_Pos 0U /*!< IPSR: ISR Position */
|
||||
#define IPSR_ISR_Msk (0x1FFUL /*<< IPSR_ISR_Pos*/) /*!< IPSR: ISR Mask */
|
||||
|
||||
|
||||
/**
|
||||
\brief Union type to access the Special-Purpose Program Status Registers (xPSR).
|
||||
*/
|
||||
typedef union
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint32_t ISR:9; /*!< bit: 0.. 8 Exception number */
|
||||
uint32_t _reserved0:1; /*!< bit: 9 Reserved */
|
||||
uint32_t ICI_IT_1:6; /*!< bit: 10..15 ICI/IT part 1 */
|
||||
uint32_t GE:4; /*!< bit: 16..19 Greater than or Equal flags */
|
||||
uint32_t _reserved1:4; /*!< bit: 20..23 Reserved */
|
||||
uint32_t T:1; /*!< bit: 24 Thumb bit */
|
||||
uint32_t ICI_IT_2:2; /*!< bit: 25..26 ICI/IT part 2 */
|
||||
uint32_t Q:1; /*!< bit: 27 Saturation condition flag */
|
||||
uint32_t V:1; /*!< bit: 28 Overflow condition code flag */
|
||||
uint32_t C:1; /*!< bit: 29 Carry condition code flag */
|
||||
uint32_t Z:1; /*!< bit: 30 Zero condition code flag */
|
||||
uint32_t N:1; /*!< bit: 31 Negative condition code flag */
|
||||
} b; /*!< Structure used for bit access */
|
||||
uint32_t w; /*!< Type used for word access */
|
||||
} xPSR_Type;
|
||||
|
||||
/* xPSR Register Definitions */
|
||||
#define xPSR_N_Pos 31U /*!< xPSR: N Position */
|
||||
#define xPSR_N_Msk (1UL << xPSR_N_Pos) /*!< xPSR: N Mask */
|
||||
|
||||
#define xPSR_Z_Pos 30U /*!< xPSR: Z Position */
|
||||
#define xPSR_Z_Msk (1UL << xPSR_Z_Pos) /*!< xPSR: Z Mask */
|
||||
|
||||
#define xPSR_C_Pos 29U /*!< xPSR: C Position */
|
||||
#define xPSR_C_Msk (1UL << xPSR_C_Pos) /*!< xPSR: C Mask */
|
||||
|
||||
#define xPSR_V_Pos 28U /*!< xPSR: V Position */
|
||||
#define xPSR_V_Msk (1UL << xPSR_V_Pos) /*!< xPSR: V Mask */
|
||||
|
||||
#define xPSR_Q_Pos 27U /*!< xPSR: Q Position */
|
||||
#define xPSR_Q_Msk (1UL << xPSR_Q_Pos) /*!< xPSR: Q Mask */
|
||||
|
||||
#define xPSR_ICI_IT_2_Pos 25U /*!< xPSR: ICI/IT part 2 Position */
|
||||
#define xPSR_ICI_IT_2_Msk (3UL << xPSR_ICI_IT_2_Pos) /*!< xPSR: ICI/IT part 2 Mask */
|
||||
|
||||
#define xPSR_T_Pos 24U /*!< xPSR: T Position */
|
||||
#define xPSR_T_Msk (1UL << xPSR_T_Pos) /*!< xPSR: T Mask */
|
||||
|
||||
#define xPSR_GE_Pos 16U /*!< xPSR: GE Position */
|
||||
#define xPSR_GE_Msk (0xFUL << xPSR_GE_Pos) /*!< xPSR: GE Mask */
|
||||
|
||||
#define xPSR_ICI_IT_1_Pos 10U /*!< xPSR: ICI/IT part 1 Position */
|
||||
#define xPSR_ICI_IT_1_Msk (0x3FUL << xPSR_ICI_IT_1_Pos) /*!< xPSR: ICI/IT part 1 Mask */
|
||||
|
||||
#define xPSR_ISR_Pos 0U /*!< xPSR: ISR Position */
|
||||
#define xPSR_ISR_Msk (0x1FFUL /*<< xPSR_ISR_Pos*/) /*!< xPSR: ISR Mask */
|
||||
|
||||
|
||||
/**
|
||||
\brief Union type to access the Control Registers (CONTROL).
|
||||
*/
|
||||
typedef union
|
||||
{
|
||||
struct
|
||||
{
|
||||
uint32_t nPRIV:1; /*!< bit: 0 Execution privilege in Thread mode */
|
||||
uint32_t SPSEL:1; /*!< bit: 1 Stack to be used */
|
||||
uint32_t FPCA:1; /*!< bit: 2 FP extension active flag */
|
||||
uint32_t _reserved0:29; /*!< bit: 3..31 Reserved */
|
||||
} b; /*!< Structure used for bit access */
|
||||
uint32_t w; /*!< Type used for word access */
|
||||
} CONTROL_Type;
|
||||
|
||||
/* CONTROL Register Definitions */
|
||||
#define CONTROL_FPCA_Pos 2U /*!< CONTROL: FPCA Position */
|
||||
#define CONTROL_FPCA_Msk (1UL << CONTROL_FPCA_Pos) /*!< CONTROL: FPCA Mask */
|
||||
|
||||
#define CONTROL_SPSEL_Pos 1U /*!< CONTROL: SPSEL Position */
|
||||
#define CONTROL_SPSEL_Msk (1UL << CONTROL_SPSEL_Pos) /*!< CONTROL: SPSEL Mask */
|
||||
|
||||
#define CONTROL_nPRIV_Pos 0U /*!< CONTROL: nPRIV Position */
|
||||
#define CONTROL_nPRIV_Msk (1UL /*<< CONTROL_nPRIV_Pos*/) /*!< CONTROL: nPRIV Mask */
|
||||
|
||||
/*@} end of group CMSIS_CORE */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_NVIC Nested Vectored Interrupt Controller (NVIC)
|
||||
\brief Type definitions for the NVIC Registers
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Nested Vectored Interrupt Controller (NVIC).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t ISER[8U]; /*!< Offset: 0x000 (R/W) Interrupt Set Enable Register */
|
||||
uint32_t RESERVED0[24U];
|
||||
__IOM uint32_t ICER[8U]; /*!< Offset: 0x080 (R/W) Interrupt Clear Enable Register */
|
||||
uint32_t RSERVED1[24U];
|
||||
__IOM uint32_t ISPR[8U]; /*!< Offset: 0x100 (R/W) Interrupt Set Pending Register */
|
||||
uint32_t RESERVED2[24U];
|
||||
__IOM uint32_t ICPR[8U]; /*!< Offset: 0x180 (R/W) Interrupt Clear Pending Register */
|
||||
uint32_t RESERVED3[24U];
|
||||
__IOM uint32_t IABR[8U]; /*!< Offset: 0x200 (R/W) Interrupt Active bit Register */
|
||||
uint32_t RESERVED4[56U];
|
||||
__IOM uint8_t IP[240U]; /*!< Offset: 0x300 (R/W) Interrupt Priority Register (8Bit wide) */
|
||||
uint32_t RESERVED5[644U];
|
||||
__OM uint32_t STIR; /*!< Offset: 0xE00 ( /W) Software Trigger Interrupt Register */
|
||||
} NVIC_Type;
|
||||
|
||||
/* Software Triggered Interrupt Register Definitions */
|
||||
#define NVIC_STIR_INTID_Pos 0U /*!< STIR: INTLINESNUM Position */
|
||||
#define NVIC_STIR_INTID_Msk (0x1FFUL /*<< NVIC_STIR_INTID_Pos*/) /*!< STIR: INTLINESNUM Mask */
|
||||
|
||||
/*@} end of group CMSIS_NVIC */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_SCB System Control Block (SCB)
|
||||
\brief Type definitions for the System Control Block Registers
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the System Control Block (SCB).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IM uint32_t CPUID; /*!< Offset: 0x000 (R/ ) CPUID Base Register */
|
||||
__IOM uint32_t ICSR; /*!< Offset: 0x004 (R/W) Interrupt Control and State Register */
|
||||
__IOM uint32_t VTOR; /*!< Offset: 0x008 (R/W) Vector Table Offset Register */
|
||||
__IOM uint32_t AIRCR; /*!< Offset: 0x00C (R/W) Application Interrupt and Reset Control Register */
|
||||
__IOM uint32_t SCR; /*!< Offset: 0x010 (R/W) System Control Register */
|
||||
__IOM uint32_t CCR; /*!< Offset: 0x014 (R/W) Configuration Control Register */
|
||||
__IOM uint8_t SHP[12U]; /*!< Offset: 0x018 (R/W) System Handlers Priority Registers (4-7, 8-11, 12-15) */
|
||||
__IOM uint32_t SHCSR; /*!< Offset: 0x024 (R/W) System Handler Control and State Register */
|
||||
__IOM uint32_t CFSR; /*!< Offset: 0x028 (R/W) Configurable Fault Status Register */
|
||||
__IOM uint32_t HFSR; /*!< Offset: 0x02C (R/W) HardFault Status Register */
|
||||
__IOM uint32_t DFSR; /*!< Offset: 0x030 (R/W) Debug Fault Status Register */
|
||||
__IOM uint32_t MMFAR; /*!< Offset: 0x034 (R/W) MemManage Fault Address Register */
|
||||
__IOM uint32_t BFAR; /*!< Offset: 0x038 (R/W) BusFault Address Register */
|
||||
__IOM uint32_t AFSR; /*!< Offset: 0x03C (R/W) Auxiliary Fault Status Register */
|
||||
__IM uint32_t PFR[2U]; /*!< Offset: 0x040 (R/ ) Processor Feature Register */
|
||||
__IM uint32_t DFR; /*!< Offset: 0x048 (R/ ) Debug Feature Register */
|
||||
__IM uint32_t ADR; /*!< Offset: 0x04C (R/ ) Auxiliary Feature Register */
|
||||
__IM uint32_t MMFR[4U]; /*!< Offset: 0x050 (R/ ) Memory Model Feature Register */
|
||||
__IM uint32_t ISAR[5U]; /*!< Offset: 0x060 (R/ ) Instruction Set Attributes Register */
|
||||
uint32_t RESERVED0[5U];
|
||||
__IOM uint32_t CPACR; /*!< Offset: 0x088 (R/W) Coprocessor Access Control Register */
|
||||
} SCB_Type;
|
||||
|
||||
/* SCB CPUID Register Definitions */
|
||||
#define SCB_CPUID_IMPLEMENTER_Pos 24U /*!< SCB CPUID: IMPLEMENTER Position */
|
||||
#define SCB_CPUID_IMPLEMENTER_Msk (0xFFUL << SCB_CPUID_IMPLEMENTER_Pos) /*!< SCB CPUID: IMPLEMENTER Mask */
|
||||
|
||||
#define SCB_CPUID_VARIANT_Pos 20U /*!< SCB CPUID: VARIANT Position */
|
||||
#define SCB_CPUID_VARIANT_Msk (0xFUL << SCB_CPUID_VARIANT_Pos) /*!< SCB CPUID: VARIANT Mask */
|
||||
|
||||
#define SCB_CPUID_ARCHITECTURE_Pos 16U /*!< SCB CPUID: ARCHITECTURE Position */
|
||||
#define SCB_CPUID_ARCHITECTURE_Msk (0xFUL << SCB_CPUID_ARCHITECTURE_Pos) /*!< SCB CPUID: ARCHITECTURE Mask */
|
||||
|
||||
#define SCB_CPUID_PARTNO_Pos 4U /*!< SCB CPUID: PARTNO Position */
|
||||
#define SCB_CPUID_PARTNO_Msk (0xFFFUL << SCB_CPUID_PARTNO_Pos) /*!< SCB CPUID: PARTNO Mask */
|
||||
|
||||
#define SCB_CPUID_REVISION_Pos 0U /*!< SCB CPUID: REVISION Position */
|
||||
#define SCB_CPUID_REVISION_Msk (0xFUL /*<< SCB_CPUID_REVISION_Pos*/) /*!< SCB CPUID: REVISION Mask */
|
||||
|
||||
/* SCB Interrupt Control State Register Definitions */
|
||||
#define SCB_ICSR_NMIPENDSET_Pos 31U /*!< SCB ICSR: NMIPENDSET Position */
|
||||
#define SCB_ICSR_NMIPENDSET_Msk (1UL << SCB_ICSR_NMIPENDSET_Pos) /*!< SCB ICSR: NMIPENDSET Mask */
|
||||
|
||||
#define SCB_ICSR_PENDSVSET_Pos 28U /*!< SCB ICSR: PENDSVSET Position */
|
||||
#define SCB_ICSR_PENDSVSET_Msk (1UL << SCB_ICSR_PENDSVSET_Pos) /*!< SCB ICSR: PENDSVSET Mask */
|
||||
|
||||
#define SCB_ICSR_PENDSVCLR_Pos 27U /*!< SCB ICSR: PENDSVCLR Position */
|
||||
#define SCB_ICSR_PENDSVCLR_Msk (1UL << SCB_ICSR_PENDSVCLR_Pos) /*!< SCB ICSR: PENDSVCLR Mask */
|
||||
|
||||
#define SCB_ICSR_PENDSTSET_Pos 26U /*!< SCB ICSR: PENDSTSET Position */
|
||||
#define SCB_ICSR_PENDSTSET_Msk (1UL << SCB_ICSR_PENDSTSET_Pos) /*!< SCB ICSR: PENDSTSET Mask */
|
||||
|
||||
#define SCB_ICSR_PENDSTCLR_Pos 25U /*!< SCB ICSR: PENDSTCLR Position */
|
||||
#define SCB_ICSR_PENDSTCLR_Msk (1UL << SCB_ICSR_PENDSTCLR_Pos) /*!< SCB ICSR: PENDSTCLR Mask */
|
||||
|
||||
#define SCB_ICSR_ISRPREEMPT_Pos 23U /*!< SCB ICSR: ISRPREEMPT Position */
|
||||
#define SCB_ICSR_ISRPREEMPT_Msk (1UL << SCB_ICSR_ISRPREEMPT_Pos) /*!< SCB ICSR: ISRPREEMPT Mask */
|
||||
|
||||
#define SCB_ICSR_ISRPENDING_Pos 22U /*!< SCB ICSR: ISRPENDING Position */
|
||||
#define SCB_ICSR_ISRPENDING_Msk (1UL << SCB_ICSR_ISRPENDING_Pos) /*!< SCB ICSR: ISRPENDING Mask */
|
||||
|
||||
#define SCB_ICSR_VECTPENDING_Pos 12U /*!< SCB ICSR: VECTPENDING Position */
|
||||
#define SCB_ICSR_VECTPENDING_Msk (0x1FFUL << SCB_ICSR_VECTPENDING_Pos) /*!< SCB ICSR: VECTPENDING Mask */
|
||||
|
||||
#define SCB_ICSR_RETTOBASE_Pos 11U /*!< SCB ICSR: RETTOBASE Position */
|
||||
#define SCB_ICSR_RETTOBASE_Msk (1UL << SCB_ICSR_RETTOBASE_Pos) /*!< SCB ICSR: RETTOBASE Mask */
|
||||
|
||||
#define SCB_ICSR_VECTACTIVE_Pos 0U /*!< SCB ICSR: VECTACTIVE Position */
|
||||
#define SCB_ICSR_VECTACTIVE_Msk (0x1FFUL /*<< SCB_ICSR_VECTACTIVE_Pos*/) /*!< SCB ICSR: VECTACTIVE Mask */
|
||||
|
||||
/* SCB Vector Table Offset Register Definitions */
|
||||
#define SCB_VTOR_TBLOFF_Pos 7U /*!< SCB VTOR: TBLOFF Position */
|
||||
#define SCB_VTOR_TBLOFF_Msk (0x1FFFFFFUL << SCB_VTOR_TBLOFF_Pos) /*!< SCB VTOR: TBLOFF Mask */
|
||||
|
||||
/* SCB Application Interrupt and Reset Control Register Definitions */
|
||||
#define SCB_AIRCR_VECTKEY_Pos 16U /*!< SCB AIRCR: VECTKEY Position */
|
||||
#define SCB_AIRCR_VECTKEY_Msk (0xFFFFUL << SCB_AIRCR_VECTKEY_Pos) /*!< SCB AIRCR: VECTKEY Mask */
|
||||
|
||||
#define SCB_AIRCR_VECTKEYSTAT_Pos 16U /*!< SCB AIRCR: VECTKEYSTAT Position */
|
||||
#define SCB_AIRCR_VECTKEYSTAT_Msk (0xFFFFUL << SCB_AIRCR_VECTKEYSTAT_Pos) /*!< SCB AIRCR: VECTKEYSTAT Mask */
|
||||
|
||||
#define SCB_AIRCR_ENDIANESS_Pos 15U /*!< SCB AIRCR: ENDIANESS Position */
|
||||
#define SCB_AIRCR_ENDIANESS_Msk (1UL << SCB_AIRCR_ENDIANESS_Pos) /*!< SCB AIRCR: ENDIANESS Mask */
|
||||
|
||||
#define SCB_AIRCR_PRIGROUP_Pos 8U /*!< SCB AIRCR: PRIGROUP Position */
|
||||
#define SCB_AIRCR_PRIGROUP_Msk (7UL << SCB_AIRCR_PRIGROUP_Pos) /*!< SCB AIRCR: PRIGROUP Mask */
|
||||
|
||||
#define SCB_AIRCR_SYSRESETREQ_Pos 2U /*!< SCB AIRCR: SYSRESETREQ Position */
|
||||
#define SCB_AIRCR_SYSRESETREQ_Msk (1UL << SCB_AIRCR_SYSRESETREQ_Pos) /*!< SCB AIRCR: SYSRESETREQ Mask */
|
||||
|
||||
#define SCB_AIRCR_VECTCLRACTIVE_Pos 1U /*!< SCB AIRCR: VECTCLRACTIVE Position */
|
||||
#define SCB_AIRCR_VECTCLRACTIVE_Msk (1UL << SCB_AIRCR_VECTCLRACTIVE_Pos) /*!< SCB AIRCR: VECTCLRACTIVE Mask */
|
||||
|
||||
#define SCB_AIRCR_VECTRESET_Pos 0U /*!< SCB AIRCR: VECTRESET Position */
|
||||
#define SCB_AIRCR_VECTRESET_Msk (1UL /*<< SCB_AIRCR_VECTRESET_Pos*/) /*!< SCB AIRCR: VECTRESET Mask */
|
||||
|
||||
/* SCB System Control Register Definitions */
|
||||
#define SCB_SCR_SEVONPEND_Pos 4U /*!< SCB SCR: SEVONPEND Position */
|
||||
#define SCB_SCR_SEVONPEND_Msk (1UL << SCB_SCR_SEVONPEND_Pos) /*!< SCB SCR: SEVONPEND Mask */
|
||||
|
||||
#define SCB_SCR_SLEEPDEEP_Pos 2U /*!< SCB SCR: SLEEPDEEP Position */
|
||||
#define SCB_SCR_SLEEPDEEP_Msk (1UL << SCB_SCR_SLEEPDEEP_Pos) /*!< SCB SCR: SLEEPDEEP Mask */
|
||||
|
||||
#define SCB_SCR_SLEEPONEXIT_Pos 1U /*!< SCB SCR: SLEEPONEXIT Position */
|
||||
#define SCB_SCR_SLEEPONEXIT_Msk (1UL << SCB_SCR_SLEEPONEXIT_Pos) /*!< SCB SCR: SLEEPONEXIT Mask */
|
||||
|
||||
/* SCB Configuration Control Register Definitions */
|
||||
#define SCB_CCR_STKALIGN_Pos 9U /*!< SCB CCR: STKALIGN Position */
|
||||
#define SCB_CCR_STKALIGN_Msk (1UL << SCB_CCR_STKALIGN_Pos) /*!< SCB CCR: STKALIGN Mask */
|
||||
|
||||
#define SCB_CCR_BFHFNMIGN_Pos 8U /*!< SCB CCR: BFHFNMIGN Position */
|
||||
#define SCB_CCR_BFHFNMIGN_Msk (1UL << SCB_CCR_BFHFNMIGN_Pos) /*!< SCB CCR: BFHFNMIGN Mask */
|
||||
|
||||
#define SCB_CCR_DIV_0_TRP_Pos 4U /*!< SCB CCR: DIV_0_TRP Position */
|
||||
#define SCB_CCR_DIV_0_TRP_Msk (1UL << SCB_CCR_DIV_0_TRP_Pos) /*!< SCB CCR: DIV_0_TRP Mask */
|
||||
|
||||
#define SCB_CCR_UNALIGN_TRP_Pos 3U /*!< SCB CCR: UNALIGN_TRP Position */
|
||||
#define SCB_CCR_UNALIGN_TRP_Msk (1UL << SCB_CCR_UNALIGN_TRP_Pos) /*!< SCB CCR: UNALIGN_TRP Mask */
|
||||
|
||||
#define SCB_CCR_USERSETMPEND_Pos 1U /*!< SCB CCR: USERSETMPEND Position */
|
||||
#define SCB_CCR_USERSETMPEND_Msk (1UL << SCB_CCR_USERSETMPEND_Pos) /*!< SCB CCR: USERSETMPEND Mask */
|
||||
|
||||
#define SCB_CCR_NONBASETHRDENA_Pos 0U /*!< SCB CCR: NONBASETHRDENA Position */
|
||||
#define SCB_CCR_NONBASETHRDENA_Msk (1UL /*<< SCB_CCR_NONBASETHRDENA_Pos*/) /*!< SCB CCR: NONBASETHRDENA Mask */
|
||||
|
||||
/* SCB System Handler Control and State Register Definitions */
|
||||
#define SCB_SHCSR_USGFAULTENA_Pos 18U /*!< SCB SHCSR: USGFAULTENA Position */
|
||||
#define SCB_SHCSR_USGFAULTENA_Msk (1UL << SCB_SHCSR_USGFAULTENA_Pos) /*!< SCB SHCSR: USGFAULTENA Mask */
|
||||
|
||||
#define SCB_SHCSR_BUSFAULTENA_Pos 17U /*!< SCB SHCSR: BUSFAULTENA Position */
|
||||
#define SCB_SHCSR_BUSFAULTENA_Msk (1UL << SCB_SHCSR_BUSFAULTENA_Pos) /*!< SCB SHCSR: BUSFAULTENA Mask */
|
||||
|
||||
#define SCB_SHCSR_MEMFAULTENA_Pos 16U /*!< SCB SHCSR: MEMFAULTENA Position */
|
||||
#define SCB_SHCSR_MEMFAULTENA_Msk (1UL << SCB_SHCSR_MEMFAULTENA_Pos) /*!< SCB SHCSR: MEMFAULTENA Mask */
|
||||
|
||||
#define SCB_SHCSR_SVCALLPENDED_Pos 15U /*!< SCB SHCSR: SVCALLPENDED Position */
|
||||
#define SCB_SHCSR_SVCALLPENDED_Msk (1UL << SCB_SHCSR_SVCALLPENDED_Pos) /*!< SCB SHCSR: SVCALLPENDED Mask */
|
||||
|
||||
#define SCB_SHCSR_BUSFAULTPENDED_Pos 14U /*!< SCB SHCSR: BUSFAULTPENDED Position */
|
||||
#define SCB_SHCSR_BUSFAULTPENDED_Msk (1UL << SCB_SHCSR_BUSFAULTPENDED_Pos) /*!< SCB SHCSR: BUSFAULTPENDED Mask */
|
||||
|
||||
#define SCB_SHCSR_MEMFAULTPENDED_Pos 13U /*!< SCB SHCSR: MEMFAULTPENDED Position */
|
||||
#define SCB_SHCSR_MEMFAULTPENDED_Msk (1UL << SCB_SHCSR_MEMFAULTPENDED_Pos) /*!< SCB SHCSR: MEMFAULTPENDED Mask */
|
||||
|
||||
#define SCB_SHCSR_USGFAULTPENDED_Pos 12U /*!< SCB SHCSR: USGFAULTPENDED Position */
|
||||
#define SCB_SHCSR_USGFAULTPENDED_Msk (1UL << SCB_SHCSR_USGFAULTPENDED_Pos) /*!< SCB SHCSR: USGFAULTPENDED Mask */
|
||||
|
||||
#define SCB_SHCSR_SYSTICKACT_Pos 11U /*!< SCB SHCSR: SYSTICKACT Position */
|
||||
#define SCB_SHCSR_SYSTICKACT_Msk (1UL << SCB_SHCSR_SYSTICKACT_Pos) /*!< SCB SHCSR: SYSTICKACT Mask */
|
||||
|
||||
#define SCB_SHCSR_PENDSVACT_Pos 10U /*!< SCB SHCSR: PENDSVACT Position */
|
||||
#define SCB_SHCSR_PENDSVACT_Msk (1UL << SCB_SHCSR_PENDSVACT_Pos) /*!< SCB SHCSR: PENDSVACT Mask */
|
||||
|
||||
#define SCB_SHCSR_MONITORACT_Pos 8U /*!< SCB SHCSR: MONITORACT Position */
|
||||
#define SCB_SHCSR_MONITORACT_Msk (1UL << SCB_SHCSR_MONITORACT_Pos) /*!< SCB SHCSR: MONITORACT Mask */
|
||||
|
||||
#define SCB_SHCSR_SVCALLACT_Pos 7U /*!< SCB SHCSR: SVCALLACT Position */
|
||||
#define SCB_SHCSR_SVCALLACT_Msk (1UL << SCB_SHCSR_SVCALLACT_Pos) /*!< SCB SHCSR: SVCALLACT Mask */
|
||||
|
||||
#define SCB_SHCSR_USGFAULTACT_Pos 3U /*!< SCB SHCSR: USGFAULTACT Position */
|
||||
#define SCB_SHCSR_USGFAULTACT_Msk (1UL << SCB_SHCSR_USGFAULTACT_Pos) /*!< SCB SHCSR: USGFAULTACT Mask */
|
||||
|
||||
#define SCB_SHCSR_BUSFAULTACT_Pos 1U /*!< SCB SHCSR: BUSFAULTACT Position */
|
||||
#define SCB_SHCSR_BUSFAULTACT_Msk (1UL << SCB_SHCSR_BUSFAULTACT_Pos) /*!< SCB SHCSR: BUSFAULTACT Mask */
|
||||
|
||||
#define SCB_SHCSR_MEMFAULTACT_Pos 0U /*!< SCB SHCSR: MEMFAULTACT Position */
|
||||
#define SCB_SHCSR_MEMFAULTACT_Msk (1UL /*<< SCB_SHCSR_MEMFAULTACT_Pos*/) /*!< SCB SHCSR: MEMFAULTACT Mask */
|
||||
|
||||
/* SCB Configurable Fault Status Register Definitions */
|
||||
#define SCB_CFSR_USGFAULTSR_Pos 16U /*!< SCB CFSR: Usage Fault Status Register Position */
|
||||
#define SCB_CFSR_USGFAULTSR_Msk (0xFFFFUL << SCB_CFSR_USGFAULTSR_Pos) /*!< SCB CFSR: Usage Fault Status Register Mask */
|
||||
|
||||
#define SCB_CFSR_BUSFAULTSR_Pos 8U /*!< SCB CFSR: Bus Fault Status Register Position */
|
||||
#define SCB_CFSR_BUSFAULTSR_Msk (0xFFUL << SCB_CFSR_BUSFAULTSR_Pos) /*!< SCB CFSR: Bus Fault Status Register Mask */
|
||||
|
||||
#define SCB_CFSR_MEMFAULTSR_Pos 0U /*!< SCB CFSR: Memory Manage Fault Status Register Position */
|
||||
#define SCB_CFSR_MEMFAULTSR_Msk (0xFFUL /*<< SCB_CFSR_MEMFAULTSR_Pos*/) /*!< SCB CFSR: Memory Manage Fault Status Register Mask */
|
||||
|
||||
/* MemManage Fault Status Register (part of SCB Configurable Fault Status Register) */
|
||||
#define SCB_CFSR_MMARVALID_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 7U) /*!< SCB CFSR (MMFSR): MMARVALID Position */
|
||||
#define SCB_CFSR_MMARVALID_Msk (1UL << SCB_CFSR_MMARVALID_Pos) /*!< SCB CFSR (MMFSR): MMARVALID Mask */
|
||||
|
||||
#define SCB_CFSR_MLSPERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 5U) /*!< SCB CFSR (MMFSR): MLSPERR Position */
|
||||
#define SCB_CFSR_MLSPERR_Msk (1UL << SCB_CFSR_MLSPERR_Pos) /*!< SCB CFSR (MMFSR): MLSPERR Mask */
|
||||
|
||||
#define SCB_CFSR_MSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 4U) /*!< SCB CFSR (MMFSR): MSTKERR Position */
|
||||
#define SCB_CFSR_MSTKERR_Msk (1UL << SCB_CFSR_MSTKERR_Pos) /*!< SCB CFSR (MMFSR): MSTKERR Mask */
|
||||
|
||||
#define SCB_CFSR_MUNSTKERR_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 3U) /*!< SCB CFSR (MMFSR): MUNSTKERR Position */
|
||||
#define SCB_CFSR_MUNSTKERR_Msk (1UL << SCB_CFSR_MUNSTKERR_Pos) /*!< SCB CFSR (MMFSR): MUNSTKERR Mask */
|
||||
|
||||
#define SCB_CFSR_DACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 1U) /*!< SCB CFSR (MMFSR): DACCVIOL Position */
|
||||
#define SCB_CFSR_DACCVIOL_Msk (1UL << SCB_CFSR_DACCVIOL_Pos) /*!< SCB CFSR (MMFSR): DACCVIOL Mask */
|
||||
|
||||
#define SCB_CFSR_IACCVIOL_Pos (SCB_SHCSR_MEMFAULTACT_Pos + 0U) /*!< SCB CFSR (MMFSR): IACCVIOL Position */
|
||||
#define SCB_CFSR_IACCVIOL_Msk (1UL /*<< SCB_CFSR_IACCVIOL_Pos*/) /*!< SCB CFSR (MMFSR): IACCVIOL Mask */
|
||||
|
||||
/* BusFault Status Register (part of SCB Configurable Fault Status Register) */
|
||||
#define SCB_CFSR_BFARVALID_Pos (SCB_CFSR_BUSFAULTSR_Pos + 7U) /*!< SCB CFSR (BFSR): BFARVALID Position */
|
||||
#define SCB_CFSR_BFARVALID_Msk (1UL << SCB_CFSR_BFARVALID_Pos) /*!< SCB CFSR (BFSR): BFARVALID Mask */
|
||||
|
||||
#define SCB_CFSR_LSPERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 5U) /*!< SCB CFSR (BFSR): LSPERR Position */
|
||||
#define SCB_CFSR_LSPERR_Msk (1UL << SCB_CFSR_LSPERR_Pos) /*!< SCB CFSR (BFSR): LSPERR Mask */
|
||||
|
||||
#define SCB_CFSR_STKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 4U) /*!< SCB CFSR (BFSR): STKERR Position */
|
||||
#define SCB_CFSR_STKERR_Msk (1UL << SCB_CFSR_STKERR_Pos) /*!< SCB CFSR (BFSR): STKERR Mask */
|
||||
|
||||
#define SCB_CFSR_UNSTKERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 3U) /*!< SCB CFSR (BFSR): UNSTKERR Position */
|
||||
#define SCB_CFSR_UNSTKERR_Msk (1UL << SCB_CFSR_UNSTKERR_Pos) /*!< SCB CFSR (BFSR): UNSTKERR Mask */
|
||||
|
||||
#define SCB_CFSR_IMPRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 2U) /*!< SCB CFSR (BFSR): IMPRECISERR Position */
|
||||
#define SCB_CFSR_IMPRECISERR_Msk (1UL << SCB_CFSR_IMPRECISERR_Pos) /*!< SCB CFSR (BFSR): IMPRECISERR Mask */
|
||||
|
||||
#define SCB_CFSR_PRECISERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 1U) /*!< SCB CFSR (BFSR): PRECISERR Position */
|
||||
#define SCB_CFSR_PRECISERR_Msk (1UL << SCB_CFSR_PRECISERR_Pos) /*!< SCB CFSR (BFSR): PRECISERR Mask */
|
||||
|
||||
#define SCB_CFSR_IBUSERR_Pos (SCB_CFSR_BUSFAULTSR_Pos + 0U) /*!< SCB CFSR (BFSR): IBUSERR Position */
|
||||
#define SCB_CFSR_IBUSERR_Msk (1UL << SCB_CFSR_IBUSERR_Pos) /*!< SCB CFSR (BFSR): IBUSERR Mask */
|
||||
|
||||
/* UsageFault Status Register (part of SCB Configurable Fault Status Register) */
|
||||
#define SCB_CFSR_DIVBYZERO_Pos (SCB_CFSR_USGFAULTSR_Pos + 9U) /*!< SCB CFSR (UFSR): DIVBYZERO Position */
|
||||
#define SCB_CFSR_DIVBYZERO_Msk (1UL << SCB_CFSR_DIVBYZERO_Pos) /*!< SCB CFSR (UFSR): DIVBYZERO Mask */
|
||||
|
||||
#define SCB_CFSR_UNALIGNED_Pos (SCB_CFSR_USGFAULTSR_Pos + 8U) /*!< SCB CFSR (UFSR): UNALIGNED Position */
|
||||
#define SCB_CFSR_UNALIGNED_Msk (1UL << SCB_CFSR_UNALIGNED_Pos) /*!< SCB CFSR (UFSR): UNALIGNED Mask */
|
||||
|
||||
#define SCB_CFSR_NOCP_Pos (SCB_CFSR_USGFAULTSR_Pos + 3U) /*!< SCB CFSR (UFSR): NOCP Position */
|
||||
#define SCB_CFSR_NOCP_Msk (1UL << SCB_CFSR_NOCP_Pos) /*!< SCB CFSR (UFSR): NOCP Mask */
|
||||
|
||||
#define SCB_CFSR_INVPC_Pos (SCB_CFSR_USGFAULTSR_Pos + 2U) /*!< SCB CFSR (UFSR): INVPC Position */
|
||||
#define SCB_CFSR_INVPC_Msk (1UL << SCB_CFSR_INVPC_Pos) /*!< SCB CFSR (UFSR): INVPC Mask */
|
||||
|
||||
#define SCB_CFSR_INVSTATE_Pos (SCB_CFSR_USGFAULTSR_Pos + 1U) /*!< SCB CFSR (UFSR): INVSTATE Position */
|
||||
#define SCB_CFSR_INVSTATE_Msk (1UL << SCB_CFSR_INVSTATE_Pos) /*!< SCB CFSR (UFSR): INVSTATE Mask */
|
||||
|
||||
#define SCB_CFSR_UNDEFINSTR_Pos (SCB_CFSR_USGFAULTSR_Pos + 0U) /*!< SCB CFSR (UFSR): UNDEFINSTR Position */
|
||||
#define SCB_CFSR_UNDEFINSTR_Msk (1UL << SCB_CFSR_UNDEFINSTR_Pos) /*!< SCB CFSR (UFSR): UNDEFINSTR Mask */
|
||||
|
||||
/* SCB Hard Fault Status Register Definitions */
|
||||
#define SCB_HFSR_DEBUGEVT_Pos 31U /*!< SCB HFSR: DEBUGEVT Position */
|
||||
#define SCB_HFSR_DEBUGEVT_Msk (1UL << SCB_HFSR_DEBUGEVT_Pos) /*!< SCB HFSR: DEBUGEVT Mask */
|
||||
|
||||
#define SCB_HFSR_FORCED_Pos 30U /*!< SCB HFSR: FORCED Position */
|
||||
#define SCB_HFSR_FORCED_Msk (1UL << SCB_HFSR_FORCED_Pos) /*!< SCB HFSR: FORCED Mask */
|
||||
|
||||
#define SCB_HFSR_VECTTBL_Pos 1U /*!< SCB HFSR: VECTTBL Position */
|
||||
#define SCB_HFSR_VECTTBL_Msk (1UL << SCB_HFSR_VECTTBL_Pos) /*!< SCB HFSR: VECTTBL Mask */
|
||||
|
||||
/* SCB Debug Fault Status Register Definitions */
|
||||
#define SCB_DFSR_EXTERNAL_Pos 4U /*!< SCB DFSR: EXTERNAL Position */
|
||||
#define SCB_DFSR_EXTERNAL_Msk (1UL << SCB_DFSR_EXTERNAL_Pos) /*!< SCB DFSR: EXTERNAL Mask */
|
||||
|
||||
#define SCB_DFSR_VCATCH_Pos 3U /*!< SCB DFSR: VCATCH Position */
|
||||
#define SCB_DFSR_VCATCH_Msk (1UL << SCB_DFSR_VCATCH_Pos) /*!< SCB DFSR: VCATCH Mask */
|
||||
|
||||
#define SCB_DFSR_DWTTRAP_Pos 2U /*!< SCB DFSR: DWTTRAP Position */
|
||||
#define SCB_DFSR_DWTTRAP_Msk (1UL << SCB_DFSR_DWTTRAP_Pos) /*!< SCB DFSR: DWTTRAP Mask */
|
||||
|
||||
#define SCB_DFSR_BKPT_Pos 1U /*!< SCB DFSR: BKPT Position */
|
||||
#define SCB_DFSR_BKPT_Msk (1UL << SCB_DFSR_BKPT_Pos) /*!< SCB DFSR: BKPT Mask */
|
||||
|
||||
#define SCB_DFSR_HALTED_Pos 0U /*!< SCB DFSR: HALTED Position */
|
||||
#define SCB_DFSR_HALTED_Msk (1UL /*<< SCB_DFSR_HALTED_Pos*/) /*!< SCB DFSR: HALTED Mask */
|
||||
|
||||
/*@} end of group CMSIS_SCB */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_SCnSCB System Controls not in SCB (SCnSCB)
|
||||
\brief Type definitions for the System Control and ID Register not in the SCB
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the System Control and ID Register not in the SCB.
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t RESERVED0[1U];
|
||||
__IM uint32_t ICTR; /*!< Offset: 0x004 (R/ ) Interrupt Controller Type Register */
|
||||
__IOM uint32_t ACTLR; /*!< Offset: 0x008 (R/W) Auxiliary Control Register */
|
||||
} SCnSCB_Type;
|
||||
|
||||
/* Interrupt Controller Type Register Definitions */
|
||||
#define SCnSCB_ICTR_INTLINESNUM_Pos 0U /*!< ICTR: INTLINESNUM Position */
|
||||
#define SCnSCB_ICTR_INTLINESNUM_Msk (0xFUL /*<< SCnSCB_ICTR_INTLINESNUM_Pos*/) /*!< ICTR: INTLINESNUM Mask */
|
||||
|
||||
/* Auxiliary Control Register Definitions */
|
||||
#define SCnSCB_ACTLR_DISOOFP_Pos 9U /*!< ACTLR: DISOOFP Position */
|
||||
#define SCnSCB_ACTLR_DISOOFP_Msk (1UL << SCnSCB_ACTLR_DISOOFP_Pos) /*!< ACTLR: DISOOFP Mask */
|
||||
|
||||
#define SCnSCB_ACTLR_DISFPCA_Pos 8U /*!< ACTLR: DISFPCA Position */
|
||||
#define SCnSCB_ACTLR_DISFPCA_Msk (1UL << SCnSCB_ACTLR_DISFPCA_Pos) /*!< ACTLR: DISFPCA Mask */
|
||||
|
||||
#define SCnSCB_ACTLR_DISFOLD_Pos 2U /*!< ACTLR: DISFOLD Position */
|
||||
#define SCnSCB_ACTLR_DISFOLD_Msk (1UL << SCnSCB_ACTLR_DISFOLD_Pos) /*!< ACTLR: DISFOLD Mask */
|
||||
|
||||
#define SCnSCB_ACTLR_DISDEFWBUF_Pos 1U /*!< ACTLR: DISDEFWBUF Position */
|
||||
#define SCnSCB_ACTLR_DISDEFWBUF_Msk (1UL << SCnSCB_ACTLR_DISDEFWBUF_Pos) /*!< ACTLR: DISDEFWBUF Mask */
|
||||
|
||||
#define SCnSCB_ACTLR_DISMCYCINT_Pos 0U /*!< ACTLR: DISMCYCINT Position */
|
||||
#define SCnSCB_ACTLR_DISMCYCINT_Msk (1UL /*<< SCnSCB_ACTLR_DISMCYCINT_Pos*/) /*!< ACTLR: DISMCYCINT Mask */
|
||||
|
||||
/*@} end of group CMSIS_SCnotSCB */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_SysTick System Tick Timer (SysTick)
|
||||
\brief Type definitions for the System Timer Registers.
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the System Timer (SysTick).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) SysTick Control and Status Register */
|
||||
__IOM uint32_t LOAD; /*!< Offset: 0x004 (R/W) SysTick Reload Value Register */
|
||||
__IOM uint32_t VAL; /*!< Offset: 0x008 (R/W) SysTick Current Value Register */
|
||||
__IM uint32_t CALIB; /*!< Offset: 0x00C (R/ ) SysTick Calibration Register */
|
||||
} SysTick_Type;
|
||||
|
||||
/* SysTick Control / Status Register Definitions */
|
||||
#define SysTick_CTRL_COUNTFLAG_Pos 16U /*!< SysTick CTRL: COUNTFLAG Position */
|
||||
#define SysTick_CTRL_COUNTFLAG_Msk (1UL << SysTick_CTRL_COUNTFLAG_Pos) /*!< SysTick CTRL: COUNTFLAG Mask */
|
||||
|
||||
#define SysTick_CTRL_CLKSOURCE_Pos 2U /*!< SysTick CTRL: CLKSOURCE Position */
|
||||
#define SysTick_CTRL_CLKSOURCE_Msk (1UL << SysTick_CTRL_CLKSOURCE_Pos) /*!< SysTick CTRL: CLKSOURCE Mask */
|
||||
|
||||
#define SysTick_CTRL_TICKINT_Pos 1U /*!< SysTick CTRL: TICKINT Position */
|
||||
#define SysTick_CTRL_TICKINT_Msk (1UL << SysTick_CTRL_TICKINT_Pos) /*!< SysTick CTRL: TICKINT Mask */
|
||||
|
||||
#define SysTick_CTRL_ENABLE_Pos 0U /*!< SysTick CTRL: ENABLE Position */
|
||||
#define SysTick_CTRL_ENABLE_Msk (1UL /*<< SysTick_CTRL_ENABLE_Pos*/) /*!< SysTick CTRL: ENABLE Mask */
|
||||
|
||||
/* SysTick Reload Register Definitions */
|
||||
#define SysTick_LOAD_RELOAD_Pos 0U /*!< SysTick LOAD: RELOAD Position */
|
||||
#define SysTick_LOAD_RELOAD_Msk (0xFFFFFFUL /*<< SysTick_LOAD_RELOAD_Pos*/) /*!< SysTick LOAD: RELOAD Mask */
|
||||
|
||||
/* SysTick Current Register Definitions */
|
||||
#define SysTick_VAL_CURRENT_Pos 0U /*!< SysTick VAL: CURRENT Position */
|
||||
#define SysTick_VAL_CURRENT_Msk (0xFFFFFFUL /*<< SysTick_VAL_CURRENT_Pos*/) /*!< SysTick VAL: CURRENT Mask */
|
||||
|
||||
/* SysTick Calibration Register Definitions */
|
||||
#define SysTick_CALIB_NOREF_Pos 31U /*!< SysTick CALIB: NOREF Position */
|
||||
#define SysTick_CALIB_NOREF_Msk (1UL << SysTick_CALIB_NOREF_Pos) /*!< SysTick CALIB: NOREF Mask */
|
||||
|
||||
#define SysTick_CALIB_SKEW_Pos 30U /*!< SysTick CALIB: SKEW Position */
|
||||
#define SysTick_CALIB_SKEW_Msk (1UL << SysTick_CALIB_SKEW_Pos) /*!< SysTick CALIB: SKEW Mask */
|
||||
|
||||
#define SysTick_CALIB_TENMS_Pos 0U /*!< SysTick CALIB: TENMS Position */
|
||||
#define SysTick_CALIB_TENMS_Msk (0xFFFFFFUL /*<< SysTick_CALIB_TENMS_Pos*/) /*!< SysTick CALIB: TENMS Mask */
|
||||
|
||||
/*@} end of group CMSIS_SysTick */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_ITM Instrumentation Trace Macrocell (ITM)
|
||||
\brief Type definitions for the Instrumentation Trace Macrocell (ITM)
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Instrumentation Trace Macrocell Register (ITM).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__OM union
|
||||
{
|
||||
__OM uint8_t u8; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 8-bit */
|
||||
__OM uint16_t u16; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 16-bit */
|
||||
__OM uint32_t u32; /*!< Offset: 0x000 ( /W) ITM Stimulus Port 32-bit */
|
||||
} PORT [32U]; /*!< Offset: 0x000 ( /W) ITM Stimulus Port Registers */
|
||||
uint32_t RESERVED0[864U];
|
||||
__IOM uint32_t TER; /*!< Offset: 0xE00 (R/W) ITM Trace Enable Register */
|
||||
uint32_t RESERVED1[15U];
|
||||
__IOM uint32_t TPR; /*!< Offset: 0xE40 (R/W) ITM Trace Privilege Register */
|
||||
uint32_t RESERVED2[15U];
|
||||
__IOM uint32_t TCR; /*!< Offset: 0xE80 (R/W) ITM Trace Control Register */
|
||||
uint32_t RESERVED3[29U];
|
||||
__OM uint32_t IWR; /*!< Offset: 0xEF8 ( /W) ITM Integration Write Register */
|
||||
__IM uint32_t IRR; /*!< Offset: 0xEFC (R/ ) ITM Integration Read Register */
|
||||
__IOM uint32_t IMCR; /*!< Offset: 0xF00 (R/W) ITM Integration Mode Control Register */
|
||||
uint32_t RESERVED4[43U];
|
||||
__OM uint32_t LAR; /*!< Offset: 0xFB0 ( /W) ITM Lock Access Register */
|
||||
__IM uint32_t LSR; /*!< Offset: 0xFB4 (R/ ) ITM Lock Status Register */
|
||||
uint32_t RESERVED5[6U];
|
||||
__IM uint32_t PID4; /*!< Offset: 0xFD0 (R/ ) ITM Peripheral Identification Register #4 */
|
||||
__IM uint32_t PID5; /*!< Offset: 0xFD4 (R/ ) ITM Peripheral Identification Register #5 */
|
||||
__IM uint32_t PID6; /*!< Offset: 0xFD8 (R/ ) ITM Peripheral Identification Register #6 */
|
||||
__IM uint32_t PID7; /*!< Offset: 0xFDC (R/ ) ITM Peripheral Identification Register #7 */
|
||||
__IM uint32_t PID0; /*!< Offset: 0xFE0 (R/ ) ITM Peripheral Identification Register #0 */
|
||||
__IM uint32_t PID1; /*!< Offset: 0xFE4 (R/ ) ITM Peripheral Identification Register #1 */
|
||||
__IM uint32_t PID2; /*!< Offset: 0xFE8 (R/ ) ITM Peripheral Identification Register #2 */
|
||||
__IM uint32_t PID3; /*!< Offset: 0xFEC (R/ ) ITM Peripheral Identification Register #3 */
|
||||
__IM uint32_t CID0; /*!< Offset: 0xFF0 (R/ ) ITM Component Identification Register #0 */
|
||||
__IM uint32_t CID1; /*!< Offset: 0xFF4 (R/ ) ITM Component Identification Register #1 */
|
||||
__IM uint32_t CID2; /*!< Offset: 0xFF8 (R/ ) ITM Component Identification Register #2 */
|
||||
__IM uint32_t CID3; /*!< Offset: 0xFFC (R/ ) ITM Component Identification Register #3 */
|
||||
} ITM_Type;
|
||||
|
||||
/* ITM Trace Privilege Register Definitions */
|
||||
#define ITM_TPR_PRIVMASK_Pos 0U /*!< ITM TPR: PRIVMASK Position */
|
||||
#define ITM_TPR_PRIVMASK_Msk (0xFUL /*<< ITM_TPR_PRIVMASK_Pos*/) /*!< ITM TPR: PRIVMASK Mask */
|
||||
|
||||
/* ITM Trace Control Register Definitions */
|
||||
#define ITM_TCR_BUSY_Pos 23U /*!< ITM TCR: BUSY Position */
|
||||
#define ITM_TCR_BUSY_Msk (1UL << ITM_TCR_BUSY_Pos) /*!< ITM TCR: BUSY Mask */
|
||||
|
||||
#define ITM_TCR_TraceBusID_Pos 16U /*!< ITM TCR: ATBID Position */
|
||||
#define ITM_TCR_TraceBusID_Msk (0x7FUL << ITM_TCR_TraceBusID_Pos) /*!< ITM TCR: ATBID Mask */
|
||||
|
||||
#define ITM_TCR_GTSFREQ_Pos 10U /*!< ITM TCR: Global timestamp frequency Position */
|
||||
#define ITM_TCR_GTSFREQ_Msk (3UL << ITM_TCR_GTSFREQ_Pos) /*!< ITM TCR: Global timestamp frequency Mask */
|
||||
|
||||
#define ITM_TCR_TSPrescale_Pos 8U /*!< ITM TCR: TSPrescale Position */
|
||||
#define ITM_TCR_TSPrescale_Msk (3UL << ITM_TCR_TSPrescale_Pos) /*!< ITM TCR: TSPrescale Mask */
|
||||
|
||||
#define ITM_TCR_SWOENA_Pos 4U /*!< ITM TCR: SWOENA Position */
|
||||
#define ITM_TCR_SWOENA_Msk (1UL << ITM_TCR_SWOENA_Pos) /*!< ITM TCR: SWOENA Mask */
|
||||
|
||||
#define ITM_TCR_DWTENA_Pos 3U /*!< ITM TCR: DWTENA Position */
|
||||
#define ITM_TCR_DWTENA_Msk (1UL << ITM_TCR_DWTENA_Pos) /*!< ITM TCR: DWTENA Mask */
|
||||
|
||||
#define ITM_TCR_SYNCENA_Pos 2U /*!< ITM TCR: SYNCENA Position */
|
||||
#define ITM_TCR_SYNCENA_Msk (1UL << ITM_TCR_SYNCENA_Pos) /*!< ITM TCR: SYNCENA Mask */
|
||||
|
||||
#define ITM_TCR_TSENA_Pos 1U /*!< ITM TCR: TSENA Position */
|
||||
#define ITM_TCR_TSENA_Msk (1UL << ITM_TCR_TSENA_Pos) /*!< ITM TCR: TSENA Mask */
|
||||
|
||||
#define ITM_TCR_ITMENA_Pos 0U /*!< ITM TCR: ITM Enable bit Position */
|
||||
#define ITM_TCR_ITMENA_Msk (1UL /*<< ITM_TCR_ITMENA_Pos*/) /*!< ITM TCR: ITM Enable bit Mask */
|
||||
|
||||
/* ITM Integration Write Register Definitions */
|
||||
#define ITM_IWR_ATVALIDM_Pos 0U /*!< ITM IWR: ATVALIDM Position */
|
||||
#define ITM_IWR_ATVALIDM_Msk (1UL /*<< ITM_IWR_ATVALIDM_Pos*/) /*!< ITM IWR: ATVALIDM Mask */
|
||||
|
||||
/* ITM Integration Read Register Definitions */
|
||||
#define ITM_IRR_ATREADYM_Pos 0U /*!< ITM IRR: ATREADYM Position */
|
||||
#define ITM_IRR_ATREADYM_Msk (1UL /*<< ITM_IRR_ATREADYM_Pos*/) /*!< ITM IRR: ATREADYM Mask */
|
||||
|
||||
/* ITM Integration Mode Control Register Definitions */
|
||||
#define ITM_IMCR_INTEGRATION_Pos 0U /*!< ITM IMCR: INTEGRATION Position */
|
||||
#define ITM_IMCR_INTEGRATION_Msk (1UL /*<< ITM_IMCR_INTEGRATION_Pos*/) /*!< ITM IMCR: INTEGRATION Mask */
|
||||
|
||||
/* ITM Lock Status Register Definitions */
|
||||
#define ITM_LSR_ByteAcc_Pos 2U /*!< ITM LSR: ByteAcc Position */
|
||||
#define ITM_LSR_ByteAcc_Msk (1UL << ITM_LSR_ByteAcc_Pos) /*!< ITM LSR: ByteAcc Mask */
|
||||
|
||||
#define ITM_LSR_Access_Pos 1U /*!< ITM LSR: Access Position */
|
||||
#define ITM_LSR_Access_Msk (1UL << ITM_LSR_Access_Pos) /*!< ITM LSR: Access Mask */
|
||||
|
||||
#define ITM_LSR_Present_Pos 0U /*!< ITM LSR: Present Position */
|
||||
#define ITM_LSR_Present_Msk (1UL /*<< ITM_LSR_Present_Pos*/) /*!< ITM LSR: Present Mask */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_ITM */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_DWT Data Watchpoint and Trace (DWT)
|
||||
\brief Type definitions for the Data Watchpoint and Trace (DWT)
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Data Watchpoint and Trace Register (DWT).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t CTRL; /*!< Offset: 0x000 (R/W) Control Register */
|
||||
__IOM uint32_t CYCCNT; /*!< Offset: 0x004 (R/W) Cycle Count Register */
|
||||
__IOM uint32_t CPICNT; /*!< Offset: 0x008 (R/W) CPI Count Register */
|
||||
__IOM uint32_t EXCCNT; /*!< Offset: 0x00C (R/W) Exception Overhead Count Register */
|
||||
__IOM uint32_t SLEEPCNT; /*!< Offset: 0x010 (R/W) Sleep Count Register */
|
||||
__IOM uint32_t LSUCNT; /*!< Offset: 0x014 (R/W) LSU Count Register */
|
||||
__IOM uint32_t FOLDCNT; /*!< Offset: 0x018 (R/W) Folded-instruction Count Register */
|
||||
__IM uint32_t PCSR; /*!< Offset: 0x01C (R/ ) Program Counter Sample Register */
|
||||
__IOM uint32_t COMP0; /*!< Offset: 0x020 (R/W) Comparator Register 0 */
|
||||
__IOM uint32_t MASK0; /*!< Offset: 0x024 (R/W) Mask Register 0 */
|
||||
__IOM uint32_t FUNCTION0; /*!< Offset: 0x028 (R/W) Function Register 0 */
|
||||
uint32_t RESERVED0[1U];
|
||||
__IOM uint32_t COMP1; /*!< Offset: 0x030 (R/W) Comparator Register 1 */
|
||||
__IOM uint32_t MASK1; /*!< Offset: 0x034 (R/W) Mask Register 1 */
|
||||
__IOM uint32_t FUNCTION1; /*!< Offset: 0x038 (R/W) Function Register 1 */
|
||||
uint32_t RESERVED1[1U];
|
||||
__IOM uint32_t COMP2; /*!< Offset: 0x040 (R/W) Comparator Register 2 */
|
||||
__IOM uint32_t MASK2; /*!< Offset: 0x044 (R/W) Mask Register 2 */
|
||||
__IOM uint32_t FUNCTION2; /*!< Offset: 0x048 (R/W) Function Register 2 */
|
||||
uint32_t RESERVED2[1U];
|
||||
__IOM uint32_t COMP3; /*!< Offset: 0x050 (R/W) Comparator Register 3 */
|
||||
__IOM uint32_t MASK3; /*!< Offset: 0x054 (R/W) Mask Register 3 */
|
||||
__IOM uint32_t FUNCTION3; /*!< Offset: 0x058 (R/W) Function Register 3 */
|
||||
} DWT_Type;
|
||||
|
||||
/* DWT Control Register Definitions */
|
||||
#define DWT_CTRL_NUMCOMP_Pos 28U /*!< DWT CTRL: NUMCOMP Position */
|
||||
#define DWT_CTRL_NUMCOMP_Msk (0xFUL << DWT_CTRL_NUMCOMP_Pos) /*!< DWT CTRL: NUMCOMP Mask */
|
||||
|
||||
#define DWT_CTRL_NOTRCPKT_Pos 27U /*!< DWT CTRL: NOTRCPKT Position */
|
||||
#define DWT_CTRL_NOTRCPKT_Msk (0x1UL << DWT_CTRL_NOTRCPKT_Pos) /*!< DWT CTRL: NOTRCPKT Mask */
|
||||
|
||||
#define DWT_CTRL_NOEXTTRIG_Pos 26U /*!< DWT CTRL: NOEXTTRIG Position */
|
||||
#define DWT_CTRL_NOEXTTRIG_Msk (0x1UL << DWT_CTRL_NOEXTTRIG_Pos) /*!< DWT CTRL: NOEXTTRIG Mask */
|
||||
|
||||
#define DWT_CTRL_NOCYCCNT_Pos 25U /*!< DWT CTRL: NOCYCCNT Position */
|
||||
#define DWT_CTRL_NOCYCCNT_Msk (0x1UL << DWT_CTRL_NOCYCCNT_Pos) /*!< DWT CTRL: NOCYCCNT Mask */
|
||||
|
||||
#define DWT_CTRL_NOPRFCNT_Pos 24U /*!< DWT CTRL: NOPRFCNT Position */
|
||||
#define DWT_CTRL_NOPRFCNT_Msk (0x1UL << DWT_CTRL_NOPRFCNT_Pos) /*!< DWT CTRL: NOPRFCNT Mask */
|
||||
|
||||
#define DWT_CTRL_CYCEVTENA_Pos 22U /*!< DWT CTRL: CYCEVTENA Position */
|
||||
#define DWT_CTRL_CYCEVTENA_Msk (0x1UL << DWT_CTRL_CYCEVTENA_Pos) /*!< DWT CTRL: CYCEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_FOLDEVTENA_Pos 21U /*!< DWT CTRL: FOLDEVTENA Position */
|
||||
#define DWT_CTRL_FOLDEVTENA_Msk (0x1UL << DWT_CTRL_FOLDEVTENA_Pos) /*!< DWT CTRL: FOLDEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_LSUEVTENA_Pos 20U /*!< DWT CTRL: LSUEVTENA Position */
|
||||
#define DWT_CTRL_LSUEVTENA_Msk (0x1UL << DWT_CTRL_LSUEVTENA_Pos) /*!< DWT CTRL: LSUEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_SLEEPEVTENA_Pos 19U /*!< DWT CTRL: SLEEPEVTENA Position */
|
||||
#define DWT_CTRL_SLEEPEVTENA_Msk (0x1UL << DWT_CTRL_SLEEPEVTENA_Pos) /*!< DWT CTRL: SLEEPEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_EXCEVTENA_Pos 18U /*!< DWT CTRL: EXCEVTENA Position */
|
||||
#define DWT_CTRL_EXCEVTENA_Msk (0x1UL << DWT_CTRL_EXCEVTENA_Pos) /*!< DWT CTRL: EXCEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_CPIEVTENA_Pos 17U /*!< DWT CTRL: CPIEVTENA Position */
|
||||
#define DWT_CTRL_CPIEVTENA_Msk (0x1UL << DWT_CTRL_CPIEVTENA_Pos) /*!< DWT CTRL: CPIEVTENA Mask */
|
||||
|
||||
#define DWT_CTRL_EXCTRCENA_Pos 16U /*!< DWT CTRL: EXCTRCENA Position */
|
||||
#define DWT_CTRL_EXCTRCENA_Msk (0x1UL << DWT_CTRL_EXCTRCENA_Pos) /*!< DWT CTRL: EXCTRCENA Mask */
|
||||
|
||||
#define DWT_CTRL_PCSAMPLENA_Pos 12U /*!< DWT CTRL: PCSAMPLENA Position */
|
||||
#define DWT_CTRL_PCSAMPLENA_Msk (0x1UL << DWT_CTRL_PCSAMPLENA_Pos) /*!< DWT CTRL: PCSAMPLENA Mask */
|
||||
|
||||
#define DWT_CTRL_SYNCTAP_Pos 10U /*!< DWT CTRL: SYNCTAP Position */
|
||||
#define DWT_CTRL_SYNCTAP_Msk (0x3UL << DWT_CTRL_SYNCTAP_Pos) /*!< DWT CTRL: SYNCTAP Mask */
|
||||
|
||||
#define DWT_CTRL_CYCTAP_Pos 9U /*!< DWT CTRL: CYCTAP Position */
|
||||
#define DWT_CTRL_CYCTAP_Msk (0x1UL << DWT_CTRL_CYCTAP_Pos) /*!< DWT CTRL: CYCTAP Mask */
|
||||
|
||||
#define DWT_CTRL_POSTINIT_Pos 5U /*!< DWT CTRL: POSTINIT Position */
|
||||
#define DWT_CTRL_POSTINIT_Msk (0xFUL << DWT_CTRL_POSTINIT_Pos) /*!< DWT CTRL: POSTINIT Mask */
|
||||
|
||||
#define DWT_CTRL_POSTPRESET_Pos 1U /*!< DWT CTRL: POSTPRESET Position */
|
||||
#define DWT_CTRL_POSTPRESET_Msk (0xFUL << DWT_CTRL_POSTPRESET_Pos) /*!< DWT CTRL: POSTPRESET Mask */
|
||||
|
||||
#define DWT_CTRL_CYCCNTENA_Pos 0U /*!< DWT CTRL: CYCCNTENA Position */
|
||||
#define DWT_CTRL_CYCCNTENA_Msk (0x1UL /*<< DWT_CTRL_CYCCNTENA_Pos*/) /*!< DWT CTRL: CYCCNTENA Mask */
|
||||
|
||||
/* DWT CPI Count Register Definitions */
|
||||
#define DWT_CPICNT_CPICNT_Pos 0U /*!< DWT CPICNT: CPICNT Position */
|
||||
#define DWT_CPICNT_CPICNT_Msk (0xFFUL /*<< DWT_CPICNT_CPICNT_Pos*/) /*!< DWT CPICNT: CPICNT Mask */
|
||||
|
||||
/* DWT Exception Overhead Count Register Definitions */
|
||||
#define DWT_EXCCNT_EXCCNT_Pos 0U /*!< DWT EXCCNT: EXCCNT Position */
|
||||
#define DWT_EXCCNT_EXCCNT_Msk (0xFFUL /*<< DWT_EXCCNT_EXCCNT_Pos*/) /*!< DWT EXCCNT: EXCCNT Mask */
|
||||
|
||||
/* DWT Sleep Count Register Definitions */
|
||||
#define DWT_SLEEPCNT_SLEEPCNT_Pos 0U /*!< DWT SLEEPCNT: SLEEPCNT Position */
|
||||
#define DWT_SLEEPCNT_SLEEPCNT_Msk (0xFFUL /*<< DWT_SLEEPCNT_SLEEPCNT_Pos*/) /*!< DWT SLEEPCNT: SLEEPCNT Mask */
|
||||
|
||||
/* DWT LSU Count Register Definitions */
|
||||
#define DWT_LSUCNT_LSUCNT_Pos 0U /*!< DWT LSUCNT: LSUCNT Position */
|
||||
#define DWT_LSUCNT_LSUCNT_Msk (0xFFUL /*<< DWT_LSUCNT_LSUCNT_Pos*/) /*!< DWT LSUCNT: LSUCNT Mask */
|
||||
|
||||
/* DWT Folded-instruction Count Register Definitions */
|
||||
#define DWT_FOLDCNT_FOLDCNT_Pos 0U /*!< DWT FOLDCNT: FOLDCNT Position */
|
||||
#define DWT_FOLDCNT_FOLDCNT_Msk (0xFFUL /*<< DWT_FOLDCNT_FOLDCNT_Pos*/) /*!< DWT FOLDCNT: FOLDCNT Mask */
|
||||
|
||||
/* DWT Comparator Mask Register Definitions */
|
||||
#define DWT_MASK_MASK_Pos 0U /*!< DWT MASK: MASK Position */
|
||||
#define DWT_MASK_MASK_Msk (0x1FUL /*<< DWT_MASK_MASK_Pos*/) /*!< DWT MASK: MASK Mask */
|
||||
|
||||
/* DWT Comparator Function Register Definitions */
|
||||
#define DWT_FUNCTION_MATCHED_Pos 24U /*!< DWT FUNCTION: MATCHED Position */
|
||||
#define DWT_FUNCTION_MATCHED_Msk (0x1UL << DWT_FUNCTION_MATCHED_Pos) /*!< DWT FUNCTION: MATCHED Mask */
|
||||
|
||||
#define DWT_FUNCTION_DATAVADDR1_Pos 16U /*!< DWT FUNCTION: DATAVADDR1 Position */
|
||||
#define DWT_FUNCTION_DATAVADDR1_Msk (0xFUL << DWT_FUNCTION_DATAVADDR1_Pos) /*!< DWT FUNCTION: DATAVADDR1 Mask */
|
||||
|
||||
#define DWT_FUNCTION_DATAVADDR0_Pos 12U /*!< DWT FUNCTION: DATAVADDR0 Position */
|
||||
#define DWT_FUNCTION_DATAVADDR0_Msk (0xFUL << DWT_FUNCTION_DATAVADDR0_Pos) /*!< DWT FUNCTION: DATAVADDR0 Mask */
|
||||
|
||||
#define DWT_FUNCTION_DATAVSIZE_Pos 10U /*!< DWT FUNCTION: DATAVSIZE Position */
|
||||
#define DWT_FUNCTION_DATAVSIZE_Msk (0x3UL << DWT_FUNCTION_DATAVSIZE_Pos) /*!< DWT FUNCTION: DATAVSIZE Mask */
|
||||
|
||||
#define DWT_FUNCTION_LNK1ENA_Pos 9U /*!< DWT FUNCTION: LNK1ENA Position */
|
||||
#define DWT_FUNCTION_LNK1ENA_Msk (0x1UL << DWT_FUNCTION_LNK1ENA_Pos) /*!< DWT FUNCTION: LNK1ENA Mask */
|
||||
|
||||
#define DWT_FUNCTION_DATAVMATCH_Pos 8U /*!< DWT FUNCTION: DATAVMATCH Position */
|
||||
#define DWT_FUNCTION_DATAVMATCH_Msk (0x1UL << DWT_FUNCTION_DATAVMATCH_Pos) /*!< DWT FUNCTION: DATAVMATCH Mask */
|
||||
|
||||
#define DWT_FUNCTION_CYCMATCH_Pos 7U /*!< DWT FUNCTION: CYCMATCH Position */
|
||||
#define DWT_FUNCTION_CYCMATCH_Msk (0x1UL << DWT_FUNCTION_CYCMATCH_Pos) /*!< DWT FUNCTION: CYCMATCH Mask */
|
||||
|
||||
#define DWT_FUNCTION_EMITRANGE_Pos 5U /*!< DWT FUNCTION: EMITRANGE Position */
|
||||
#define DWT_FUNCTION_EMITRANGE_Msk (0x1UL << DWT_FUNCTION_EMITRANGE_Pos) /*!< DWT FUNCTION: EMITRANGE Mask */
|
||||
|
||||
#define DWT_FUNCTION_FUNCTION_Pos 0U /*!< DWT FUNCTION: FUNCTION Position */
|
||||
#define DWT_FUNCTION_FUNCTION_Msk (0xFUL /*<< DWT_FUNCTION_FUNCTION_Pos*/) /*!< DWT FUNCTION: FUNCTION Mask */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_DWT */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_TPI Trace Port Interface (TPI)
|
||||
\brief Type definitions for the Trace Port Interface (TPI)
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Trace Port Interface Register (TPI).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t SSPSR; /*!< Offset: 0x000 (R/ ) Supported Parallel Port Size Register */
|
||||
__IOM uint32_t CSPSR; /*!< Offset: 0x004 (R/W) Current Parallel Port Size Register */
|
||||
uint32_t RESERVED0[2U];
|
||||
__IOM uint32_t ACPR; /*!< Offset: 0x010 (R/W) Asynchronous Clock Prescaler Register */
|
||||
uint32_t RESERVED1[55U];
|
||||
__IOM uint32_t SPPR; /*!< Offset: 0x0F0 (R/W) Selected Pin Protocol Register */
|
||||
uint32_t RESERVED2[131U];
|
||||
__IM uint32_t FFSR; /*!< Offset: 0x300 (R/ ) Formatter and Flush Status Register */
|
||||
__IOM uint32_t FFCR; /*!< Offset: 0x304 (R/W) Formatter and Flush Control Register */
|
||||
__IM uint32_t FSCR; /*!< Offset: 0x308 (R/ ) Formatter Synchronization Counter Register */
|
||||
uint32_t RESERVED3[759U];
|
||||
__IM uint32_t TRIGGER; /*!< Offset: 0xEE8 (R/ ) TRIGGER */
|
||||
__IM uint32_t FIFO0; /*!< Offset: 0xEEC (R/ ) Integration ETM Data */
|
||||
__IM uint32_t ITATBCTR2; /*!< Offset: 0xEF0 (R/ ) ITATBCTR2 */
|
||||
uint32_t RESERVED4[1U];
|
||||
__IM uint32_t ITATBCTR0; /*!< Offset: 0xEF8 (R/ ) ITATBCTR0 */
|
||||
__IM uint32_t FIFO1; /*!< Offset: 0xEFC (R/ ) Integration ITM Data */
|
||||
__IOM uint32_t ITCTRL; /*!< Offset: 0xF00 (R/W) Integration Mode Control */
|
||||
uint32_t RESERVED5[39U];
|
||||
__IOM uint32_t CLAIMSET; /*!< Offset: 0xFA0 (R/W) Claim tag set */
|
||||
__IOM uint32_t CLAIMCLR; /*!< Offset: 0xFA4 (R/W) Claim tag clear */
|
||||
uint32_t RESERVED7[8U];
|
||||
__IM uint32_t DEVID; /*!< Offset: 0xFC8 (R/ ) TPIU_DEVID */
|
||||
__IM uint32_t DEVTYPE; /*!< Offset: 0xFCC (R/ ) TPIU_DEVTYPE */
|
||||
} TPI_Type;
|
||||
|
||||
/* TPI Asynchronous Clock Prescaler Register Definitions */
|
||||
#define TPI_ACPR_PRESCALER_Pos 0U /*!< TPI ACPR: PRESCALER Position */
|
||||
#define TPI_ACPR_PRESCALER_Msk (0x1FFFUL /*<< TPI_ACPR_PRESCALER_Pos*/) /*!< TPI ACPR: PRESCALER Mask */
|
||||
|
||||
/* TPI Selected Pin Protocol Register Definitions */
|
||||
#define TPI_SPPR_TXMODE_Pos 0U /*!< TPI SPPR: TXMODE Position */
|
||||
#define TPI_SPPR_TXMODE_Msk (0x3UL /*<< TPI_SPPR_TXMODE_Pos*/) /*!< TPI SPPR: TXMODE Mask */
|
||||
|
||||
/* TPI Formatter and Flush Status Register Definitions */
|
||||
#define TPI_FFSR_FtNonStop_Pos 3U /*!< TPI FFSR: FtNonStop Position */
|
||||
#define TPI_FFSR_FtNonStop_Msk (0x1UL << TPI_FFSR_FtNonStop_Pos) /*!< TPI FFSR: FtNonStop Mask */
|
||||
|
||||
#define TPI_FFSR_TCPresent_Pos 2U /*!< TPI FFSR: TCPresent Position */
|
||||
#define TPI_FFSR_TCPresent_Msk (0x1UL << TPI_FFSR_TCPresent_Pos) /*!< TPI FFSR: TCPresent Mask */
|
||||
|
||||
#define TPI_FFSR_FtStopped_Pos 1U /*!< TPI FFSR: FtStopped Position */
|
||||
#define TPI_FFSR_FtStopped_Msk (0x1UL << TPI_FFSR_FtStopped_Pos) /*!< TPI FFSR: FtStopped Mask */
|
||||
|
||||
#define TPI_FFSR_FlInProg_Pos 0U /*!< TPI FFSR: FlInProg Position */
|
||||
#define TPI_FFSR_FlInProg_Msk (0x1UL /*<< TPI_FFSR_FlInProg_Pos*/) /*!< TPI FFSR: FlInProg Mask */
|
||||
|
||||
/* TPI Formatter and Flush Control Register Definitions */
|
||||
#define TPI_FFCR_TrigIn_Pos 8U /*!< TPI FFCR: TrigIn Position */
|
||||
#define TPI_FFCR_TrigIn_Msk (0x1UL << TPI_FFCR_TrigIn_Pos) /*!< TPI FFCR: TrigIn Mask */
|
||||
|
||||
#define TPI_FFCR_EnFCont_Pos 1U /*!< TPI FFCR: EnFCont Position */
|
||||
#define TPI_FFCR_EnFCont_Msk (0x1UL << TPI_FFCR_EnFCont_Pos) /*!< TPI FFCR: EnFCont Mask */
|
||||
|
||||
/* TPI TRIGGER Register Definitions */
|
||||
#define TPI_TRIGGER_TRIGGER_Pos 0U /*!< TPI TRIGGER: TRIGGER Position */
|
||||
#define TPI_TRIGGER_TRIGGER_Msk (0x1UL /*<< TPI_TRIGGER_TRIGGER_Pos*/) /*!< TPI TRIGGER: TRIGGER Mask */
|
||||
|
||||
/* TPI Integration ETM Data Register Definitions (FIFO0) */
|
||||
#define TPI_FIFO0_ITM_ATVALID_Pos 29U /*!< TPI FIFO0: ITM_ATVALID Position */
|
||||
#define TPI_FIFO0_ITM_ATVALID_Msk (0x3UL << TPI_FIFO0_ITM_ATVALID_Pos) /*!< TPI FIFO0: ITM_ATVALID Mask */
|
||||
|
||||
#define TPI_FIFO0_ITM_bytecount_Pos 27U /*!< TPI FIFO0: ITM_bytecount Position */
|
||||
#define TPI_FIFO0_ITM_bytecount_Msk (0x3UL << TPI_FIFO0_ITM_bytecount_Pos) /*!< TPI FIFO0: ITM_bytecount Mask */
|
||||
|
||||
#define TPI_FIFO0_ETM_ATVALID_Pos 26U /*!< TPI FIFO0: ETM_ATVALID Position */
|
||||
#define TPI_FIFO0_ETM_ATVALID_Msk (0x3UL << TPI_FIFO0_ETM_ATVALID_Pos) /*!< TPI FIFO0: ETM_ATVALID Mask */
|
||||
|
||||
#define TPI_FIFO0_ETM_bytecount_Pos 24U /*!< TPI FIFO0: ETM_bytecount Position */
|
||||
#define TPI_FIFO0_ETM_bytecount_Msk (0x3UL << TPI_FIFO0_ETM_bytecount_Pos) /*!< TPI FIFO0: ETM_bytecount Mask */
|
||||
|
||||
#define TPI_FIFO0_ETM2_Pos 16U /*!< TPI FIFO0: ETM2 Position */
|
||||
#define TPI_FIFO0_ETM2_Msk (0xFFUL << TPI_FIFO0_ETM2_Pos) /*!< TPI FIFO0: ETM2 Mask */
|
||||
|
||||
#define TPI_FIFO0_ETM1_Pos 8U /*!< TPI FIFO0: ETM1 Position */
|
||||
#define TPI_FIFO0_ETM1_Msk (0xFFUL << TPI_FIFO0_ETM1_Pos) /*!< TPI FIFO0: ETM1 Mask */
|
||||
|
||||
#define TPI_FIFO0_ETM0_Pos 0U /*!< TPI FIFO0: ETM0 Position */
|
||||
#define TPI_FIFO0_ETM0_Msk (0xFFUL /*<< TPI_FIFO0_ETM0_Pos*/) /*!< TPI FIFO0: ETM0 Mask */
|
||||
|
||||
/* TPI ITATBCTR2 Register Definitions */
|
||||
#define TPI_ITATBCTR2_ATREADY_Pos 0U /*!< TPI ITATBCTR2: ATREADY Position */
|
||||
#define TPI_ITATBCTR2_ATREADY_Msk (0x1UL /*<< TPI_ITATBCTR2_ATREADY_Pos*/) /*!< TPI ITATBCTR2: ATREADY Mask */
|
||||
|
||||
/* TPI Integration ITM Data Register Definitions (FIFO1) */
|
||||
#define TPI_FIFO1_ITM_ATVALID_Pos 29U /*!< TPI FIFO1: ITM_ATVALID Position */
|
||||
#define TPI_FIFO1_ITM_ATVALID_Msk (0x3UL << TPI_FIFO1_ITM_ATVALID_Pos) /*!< TPI FIFO1: ITM_ATVALID Mask */
|
||||
|
||||
#define TPI_FIFO1_ITM_bytecount_Pos 27U /*!< TPI FIFO1: ITM_bytecount Position */
|
||||
#define TPI_FIFO1_ITM_bytecount_Msk (0x3UL << TPI_FIFO1_ITM_bytecount_Pos) /*!< TPI FIFO1: ITM_bytecount Mask */
|
||||
|
||||
#define TPI_FIFO1_ETM_ATVALID_Pos 26U /*!< TPI FIFO1: ETM_ATVALID Position */
|
||||
#define TPI_FIFO1_ETM_ATVALID_Msk (0x3UL << TPI_FIFO1_ETM_ATVALID_Pos) /*!< TPI FIFO1: ETM_ATVALID Mask */
|
||||
|
||||
#define TPI_FIFO1_ETM_bytecount_Pos 24U /*!< TPI FIFO1: ETM_bytecount Position */
|
||||
#define TPI_FIFO1_ETM_bytecount_Msk (0x3UL << TPI_FIFO1_ETM_bytecount_Pos) /*!< TPI FIFO1: ETM_bytecount Mask */
|
||||
|
||||
#define TPI_FIFO1_ITM2_Pos 16U /*!< TPI FIFO1: ITM2 Position */
|
||||
#define TPI_FIFO1_ITM2_Msk (0xFFUL << TPI_FIFO1_ITM2_Pos) /*!< TPI FIFO1: ITM2 Mask */
|
||||
|
||||
#define TPI_FIFO1_ITM1_Pos 8U /*!< TPI FIFO1: ITM1 Position */
|
||||
#define TPI_FIFO1_ITM1_Msk (0xFFUL << TPI_FIFO1_ITM1_Pos) /*!< TPI FIFO1: ITM1 Mask */
|
||||
|
||||
#define TPI_FIFO1_ITM0_Pos 0U /*!< TPI FIFO1: ITM0 Position */
|
||||
#define TPI_FIFO1_ITM0_Msk (0xFFUL /*<< TPI_FIFO1_ITM0_Pos*/) /*!< TPI FIFO1: ITM0 Mask */
|
||||
|
||||
/* TPI ITATBCTR0 Register Definitions */
|
||||
#define TPI_ITATBCTR0_ATREADY_Pos 0U /*!< TPI ITATBCTR0: ATREADY Position */
|
||||
#define TPI_ITATBCTR0_ATREADY_Msk (0x1UL /*<< TPI_ITATBCTR0_ATREADY_Pos*/) /*!< TPI ITATBCTR0: ATREADY Mask */
|
||||
|
||||
/* TPI Integration Mode Control Register Definitions */
|
||||
#define TPI_ITCTRL_Mode_Pos 0U /*!< TPI ITCTRL: Mode Position */
|
||||
#define TPI_ITCTRL_Mode_Msk (0x1UL /*<< TPI_ITCTRL_Mode_Pos*/) /*!< TPI ITCTRL: Mode Mask */
|
||||
|
||||
/* TPI DEVID Register Definitions */
|
||||
#define TPI_DEVID_NRZVALID_Pos 11U /*!< TPI DEVID: NRZVALID Position */
|
||||
#define TPI_DEVID_NRZVALID_Msk (0x1UL << TPI_DEVID_NRZVALID_Pos) /*!< TPI DEVID: NRZVALID Mask */
|
||||
|
||||
#define TPI_DEVID_MANCVALID_Pos 10U /*!< TPI DEVID: MANCVALID Position */
|
||||
#define TPI_DEVID_MANCVALID_Msk (0x1UL << TPI_DEVID_MANCVALID_Pos) /*!< TPI DEVID: MANCVALID Mask */
|
||||
|
||||
#define TPI_DEVID_PTINVALID_Pos 9U /*!< TPI DEVID: PTINVALID Position */
|
||||
#define TPI_DEVID_PTINVALID_Msk (0x1UL << TPI_DEVID_PTINVALID_Pos) /*!< TPI DEVID: PTINVALID Mask */
|
||||
|
||||
#define TPI_DEVID_MinBufSz_Pos 6U /*!< TPI DEVID: MinBufSz Position */
|
||||
#define TPI_DEVID_MinBufSz_Msk (0x7UL << TPI_DEVID_MinBufSz_Pos) /*!< TPI DEVID: MinBufSz Mask */
|
||||
|
||||
#define TPI_DEVID_AsynClkIn_Pos 5U /*!< TPI DEVID: AsynClkIn Position */
|
||||
#define TPI_DEVID_AsynClkIn_Msk (0x1UL << TPI_DEVID_AsynClkIn_Pos) /*!< TPI DEVID: AsynClkIn Mask */
|
||||
|
||||
#define TPI_DEVID_NrTraceInput_Pos 0U /*!< TPI DEVID: NrTraceInput Position */
|
||||
#define TPI_DEVID_NrTraceInput_Msk (0x1FUL /*<< TPI_DEVID_NrTraceInput_Pos*/) /*!< TPI DEVID: NrTraceInput Mask */
|
||||
|
||||
/* TPI DEVTYPE Register Definitions */
|
||||
#define TPI_DEVTYPE_MajorType_Pos 4U /*!< TPI DEVTYPE: MajorType Position */
|
||||
#define TPI_DEVTYPE_MajorType_Msk (0xFUL << TPI_DEVTYPE_MajorType_Pos) /*!< TPI DEVTYPE: MajorType Mask */
|
||||
|
||||
#define TPI_DEVTYPE_SubType_Pos 0U /*!< TPI DEVTYPE: SubType Position */
|
||||
#define TPI_DEVTYPE_SubType_Msk (0xFUL /*<< TPI_DEVTYPE_SubType_Pos*/) /*!< TPI DEVTYPE: SubType Mask */
|
||||
|
||||
/*@}*/ /* end of group CMSIS_TPI */
|
||||
|
||||
|
||||
#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_MPU Memory Protection Unit (MPU)
|
||||
\brief Type definitions for the Memory Protection Unit (MPU)
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Memory Protection Unit (MPU).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IM uint32_t TYPE; /*!< Offset: 0x000 (R/ ) MPU Type Register */
|
||||
__IOM uint32_t CTRL; /*!< Offset: 0x004 (R/W) MPU Control Register */
|
||||
__IOM uint32_t RNR; /*!< Offset: 0x008 (R/W) MPU Region RNRber Register */
|
||||
__IOM uint32_t RBAR; /*!< Offset: 0x00C (R/W) MPU Region Base Address Register */
|
||||
__IOM uint32_t RASR; /*!< Offset: 0x010 (R/W) MPU Region Attribute and Size Register */
|
||||
__IOM uint32_t RBAR_A1; /*!< Offset: 0x014 (R/W) MPU Alias 1 Region Base Address Register */
|
||||
__IOM uint32_t RASR_A1; /*!< Offset: 0x018 (R/W) MPU Alias 1 Region Attribute and Size Register */
|
||||
__IOM uint32_t RBAR_A2; /*!< Offset: 0x01C (R/W) MPU Alias 2 Region Base Address Register */
|
||||
__IOM uint32_t RASR_A2; /*!< Offset: 0x020 (R/W) MPU Alias 2 Region Attribute and Size Register */
|
||||
__IOM uint32_t RBAR_A3; /*!< Offset: 0x024 (R/W) MPU Alias 3 Region Base Address Register */
|
||||
__IOM uint32_t RASR_A3; /*!< Offset: 0x028 (R/W) MPU Alias 3 Region Attribute and Size Register */
|
||||
} MPU_Type;
|
||||
|
||||
#define MPU_TYPE_RALIASES 4U
|
||||
|
||||
/* MPU Type Register Definitions */
|
||||
#define MPU_TYPE_IREGION_Pos 16U /*!< MPU TYPE: IREGION Position */
|
||||
#define MPU_TYPE_IREGION_Msk (0xFFUL << MPU_TYPE_IREGION_Pos) /*!< MPU TYPE: IREGION Mask */
|
||||
|
||||
#define MPU_TYPE_DREGION_Pos 8U /*!< MPU TYPE: DREGION Position */
|
||||
#define MPU_TYPE_DREGION_Msk (0xFFUL << MPU_TYPE_DREGION_Pos) /*!< MPU TYPE: DREGION Mask */
|
||||
|
||||
#define MPU_TYPE_SEPARATE_Pos 0U /*!< MPU TYPE: SEPARATE Position */
|
||||
#define MPU_TYPE_SEPARATE_Msk (1UL /*<< MPU_TYPE_SEPARATE_Pos*/) /*!< MPU TYPE: SEPARATE Mask */
|
||||
|
||||
/* MPU Control Register Definitions */
|
||||
#define MPU_CTRL_PRIVDEFENA_Pos 2U /*!< MPU CTRL: PRIVDEFENA Position */
|
||||
#define MPU_CTRL_PRIVDEFENA_Msk (1UL << MPU_CTRL_PRIVDEFENA_Pos) /*!< MPU CTRL: PRIVDEFENA Mask */
|
||||
|
||||
#define MPU_CTRL_HFNMIENA_Pos 1U /*!< MPU CTRL: HFNMIENA Position */
|
||||
#define MPU_CTRL_HFNMIENA_Msk (1UL << MPU_CTRL_HFNMIENA_Pos) /*!< MPU CTRL: HFNMIENA Mask */
|
||||
|
||||
#define MPU_CTRL_ENABLE_Pos 0U /*!< MPU CTRL: ENABLE Position */
|
||||
#define MPU_CTRL_ENABLE_Msk (1UL /*<< MPU_CTRL_ENABLE_Pos*/) /*!< MPU CTRL: ENABLE Mask */
|
||||
|
||||
/* MPU Region Number Register Definitions */
|
||||
#define MPU_RNR_REGION_Pos 0U /*!< MPU RNR: REGION Position */
|
||||
#define MPU_RNR_REGION_Msk (0xFFUL /*<< MPU_RNR_REGION_Pos*/) /*!< MPU RNR: REGION Mask */
|
||||
|
||||
/* MPU Region Base Address Register Definitions */
|
||||
#define MPU_RBAR_ADDR_Pos 5U /*!< MPU RBAR: ADDR Position */
|
||||
#define MPU_RBAR_ADDR_Msk (0x7FFFFFFUL << MPU_RBAR_ADDR_Pos) /*!< MPU RBAR: ADDR Mask */
|
||||
|
||||
#define MPU_RBAR_VALID_Pos 4U /*!< MPU RBAR: VALID Position */
|
||||
#define MPU_RBAR_VALID_Msk (1UL << MPU_RBAR_VALID_Pos) /*!< MPU RBAR: VALID Mask */
|
||||
|
||||
#define MPU_RBAR_REGION_Pos 0U /*!< MPU RBAR: REGION Position */
|
||||
#define MPU_RBAR_REGION_Msk (0xFUL /*<< MPU_RBAR_REGION_Pos*/) /*!< MPU RBAR: REGION Mask */
|
||||
|
||||
/* MPU Region Attribute and Size Register Definitions */
|
||||
#define MPU_RASR_ATTRS_Pos 16U /*!< MPU RASR: MPU Region Attribute field Position */
|
||||
#define MPU_RASR_ATTRS_Msk (0xFFFFUL << MPU_RASR_ATTRS_Pos) /*!< MPU RASR: MPU Region Attribute field Mask */
|
||||
|
||||
#define MPU_RASR_XN_Pos 28U /*!< MPU RASR: ATTRS.XN Position */
|
||||
#define MPU_RASR_XN_Msk (1UL << MPU_RASR_XN_Pos) /*!< MPU RASR: ATTRS.XN Mask */
|
||||
|
||||
#define MPU_RASR_AP_Pos 24U /*!< MPU RASR: ATTRS.AP Position */
|
||||
#define MPU_RASR_AP_Msk (0x7UL << MPU_RASR_AP_Pos) /*!< MPU RASR: ATTRS.AP Mask */
|
||||
|
||||
#define MPU_RASR_TEX_Pos 19U /*!< MPU RASR: ATTRS.TEX Position */
|
||||
#define MPU_RASR_TEX_Msk (0x7UL << MPU_RASR_TEX_Pos) /*!< MPU RASR: ATTRS.TEX Mask */
|
||||
|
||||
#define MPU_RASR_S_Pos 18U /*!< MPU RASR: ATTRS.S Position */
|
||||
#define MPU_RASR_S_Msk (1UL << MPU_RASR_S_Pos) /*!< MPU RASR: ATTRS.S Mask */
|
||||
|
||||
#define MPU_RASR_C_Pos 17U /*!< MPU RASR: ATTRS.C Position */
|
||||
#define MPU_RASR_C_Msk (1UL << MPU_RASR_C_Pos) /*!< MPU RASR: ATTRS.C Mask */
|
||||
|
||||
#define MPU_RASR_B_Pos 16U /*!< MPU RASR: ATTRS.B Position */
|
||||
#define MPU_RASR_B_Msk (1UL << MPU_RASR_B_Pos) /*!< MPU RASR: ATTRS.B Mask */
|
||||
|
||||
#define MPU_RASR_SRD_Pos 8U /*!< MPU RASR: Sub-Region Disable Position */
|
||||
#define MPU_RASR_SRD_Msk (0xFFUL << MPU_RASR_SRD_Pos) /*!< MPU RASR: Sub-Region Disable Mask */
|
||||
|
||||
#define MPU_RASR_SIZE_Pos 1U /*!< MPU RASR: Region Size Field Position */
|
||||
#define MPU_RASR_SIZE_Msk (0x1FUL << MPU_RASR_SIZE_Pos) /*!< MPU RASR: Region Size Field Mask */
|
||||
|
||||
#define MPU_RASR_ENABLE_Pos 0U /*!< MPU RASR: Region enable bit Position */
|
||||
#define MPU_RASR_ENABLE_Msk (1UL /*<< MPU_RASR_ENABLE_Pos*/) /*!< MPU RASR: Region enable bit Disable Mask */
|
||||
|
||||
/*@} end of group CMSIS_MPU */
|
||||
#endif /* defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U) */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_FPU Floating Point Unit (FPU)
|
||||
\brief Type definitions for the Floating Point Unit (FPU)
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Floating Point Unit (FPU).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
uint32_t RESERVED0[1U];
|
||||
__IOM uint32_t FPCCR; /*!< Offset: 0x004 (R/W) Floating-Point Context Control Register */
|
||||
__IOM uint32_t FPCAR; /*!< Offset: 0x008 (R/W) Floating-Point Context Address Register */
|
||||
__IOM uint32_t FPDSCR; /*!< Offset: 0x00C (R/W) Floating-Point Default Status Control Register */
|
||||
__IM uint32_t MVFR0; /*!< Offset: 0x010 (R/ ) Media and FP Feature Register 0 */
|
||||
__IM uint32_t MVFR1; /*!< Offset: 0x014 (R/ ) Media and FP Feature Register 1 */
|
||||
} FPU_Type;
|
||||
|
||||
/* Floating-Point Context Control Register Definitions */
|
||||
#define FPU_FPCCR_ASPEN_Pos 31U /*!< FPCCR: ASPEN bit Position */
|
||||
#define FPU_FPCCR_ASPEN_Msk (1UL << FPU_FPCCR_ASPEN_Pos) /*!< FPCCR: ASPEN bit Mask */
|
||||
|
||||
#define FPU_FPCCR_LSPEN_Pos 30U /*!< FPCCR: LSPEN Position */
|
||||
#define FPU_FPCCR_LSPEN_Msk (1UL << FPU_FPCCR_LSPEN_Pos) /*!< FPCCR: LSPEN bit Mask */
|
||||
|
||||
#define FPU_FPCCR_MONRDY_Pos 8U /*!< FPCCR: MONRDY Position */
|
||||
#define FPU_FPCCR_MONRDY_Msk (1UL << FPU_FPCCR_MONRDY_Pos) /*!< FPCCR: MONRDY bit Mask */
|
||||
|
||||
#define FPU_FPCCR_BFRDY_Pos 6U /*!< FPCCR: BFRDY Position */
|
||||
#define FPU_FPCCR_BFRDY_Msk (1UL << FPU_FPCCR_BFRDY_Pos) /*!< FPCCR: BFRDY bit Mask */
|
||||
|
||||
#define FPU_FPCCR_MMRDY_Pos 5U /*!< FPCCR: MMRDY Position */
|
||||
#define FPU_FPCCR_MMRDY_Msk (1UL << FPU_FPCCR_MMRDY_Pos) /*!< FPCCR: MMRDY bit Mask */
|
||||
|
||||
#define FPU_FPCCR_HFRDY_Pos 4U /*!< FPCCR: HFRDY Position */
|
||||
#define FPU_FPCCR_HFRDY_Msk (1UL << FPU_FPCCR_HFRDY_Pos) /*!< FPCCR: HFRDY bit Mask */
|
||||
|
||||
#define FPU_FPCCR_THREAD_Pos 3U /*!< FPCCR: processor mode bit Position */
|
||||
#define FPU_FPCCR_THREAD_Msk (1UL << FPU_FPCCR_THREAD_Pos) /*!< FPCCR: processor mode active bit Mask */
|
||||
|
||||
#define FPU_FPCCR_USER_Pos 1U /*!< FPCCR: privilege level bit Position */
|
||||
#define FPU_FPCCR_USER_Msk (1UL << FPU_FPCCR_USER_Pos) /*!< FPCCR: privilege level bit Mask */
|
||||
|
||||
#define FPU_FPCCR_LSPACT_Pos 0U /*!< FPCCR: Lazy state preservation active bit Position */
|
||||
#define FPU_FPCCR_LSPACT_Msk (1UL /*<< FPU_FPCCR_LSPACT_Pos*/) /*!< FPCCR: Lazy state preservation active bit Mask */
|
||||
|
||||
/* Floating-Point Context Address Register Definitions */
|
||||
#define FPU_FPCAR_ADDRESS_Pos 3U /*!< FPCAR: ADDRESS bit Position */
|
||||
#define FPU_FPCAR_ADDRESS_Msk (0x1FFFFFFFUL << FPU_FPCAR_ADDRESS_Pos) /*!< FPCAR: ADDRESS bit Mask */
|
||||
|
||||
/* Floating-Point Default Status Control Register Definitions */
|
||||
#define FPU_FPDSCR_AHP_Pos 26U /*!< FPDSCR: AHP bit Position */
|
||||
#define FPU_FPDSCR_AHP_Msk (1UL << FPU_FPDSCR_AHP_Pos) /*!< FPDSCR: AHP bit Mask */
|
||||
|
||||
#define FPU_FPDSCR_DN_Pos 25U /*!< FPDSCR: DN bit Position */
|
||||
#define FPU_FPDSCR_DN_Msk (1UL << FPU_FPDSCR_DN_Pos) /*!< FPDSCR: DN bit Mask */
|
||||
|
||||
#define FPU_FPDSCR_FZ_Pos 24U /*!< FPDSCR: FZ bit Position */
|
||||
#define FPU_FPDSCR_FZ_Msk (1UL << FPU_FPDSCR_FZ_Pos) /*!< FPDSCR: FZ bit Mask */
|
||||
|
||||
#define FPU_FPDSCR_RMode_Pos 22U /*!< FPDSCR: RMode bit Position */
|
||||
#define FPU_FPDSCR_RMode_Msk (3UL << FPU_FPDSCR_RMode_Pos) /*!< FPDSCR: RMode bit Mask */
|
||||
|
||||
/* Media and FP Feature Register 0 Definitions */
|
||||
#define FPU_MVFR0_FP_rounding_modes_Pos 28U /*!< MVFR0: FP rounding modes bits Position */
|
||||
#define FPU_MVFR0_FP_rounding_modes_Msk (0xFUL << FPU_MVFR0_FP_rounding_modes_Pos) /*!< MVFR0: FP rounding modes bits Mask */
|
||||
|
||||
#define FPU_MVFR0_Short_vectors_Pos 24U /*!< MVFR0: Short vectors bits Position */
|
||||
#define FPU_MVFR0_Short_vectors_Msk (0xFUL << FPU_MVFR0_Short_vectors_Pos) /*!< MVFR0: Short vectors bits Mask */
|
||||
|
||||
#define FPU_MVFR0_Square_root_Pos 20U /*!< MVFR0: Square root bits Position */
|
||||
#define FPU_MVFR0_Square_root_Msk (0xFUL << FPU_MVFR0_Square_root_Pos) /*!< MVFR0: Square root bits Mask */
|
||||
|
||||
#define FPU_MVFR0_Divide_Pos 16U /*!< MVFR0: Divide bits Position */
|
||||
#define FPU_MVFR0_Divide_Msk (0xFUL << FPU_MVFR0_Divide_Pos) /*!< MVFR0: Divide bits Mask */
|
||||
|
||||
#define FPU_MVFR0_FP_excep_trapping_Pos 12U /*!< MVFR0: FP exception trapping bits Position */
|
||||
#define FPU_MVFR0_FP_excep_trapping_Msk (0xFUL << FPU_MVFR0_FP_excep_trapping_Pos) /*!< MVFR0: FP exception trapping bits Mask */
|
||||
|
||||
#define FPU_MVFR0_Double_precision_Pos 8U /*!< MVFR0: Double-precision bits Position */
|
||||
#define FPU_MVFR0_Double_precision_Msk (0xFUL << FPU_MVFR0_Double_precision_Pos) /*!< MVFR0: Double-precision bits Mask */
|
||||
|
||||
#define FPU_MVFR0_Single_precision_Pos 4U /*!< MVFR0: Single-precision bits Position */
|
||||
#define FPU_MVFR0_Single_precision_Msk (0xFUL << FPU_MVFR0_Single_precision_Pos) /*!< MVFR0: Single-precision bits Mask */
|
||||
|
||||
#define FPU_MVFR0_A_SIMD_registers_Pos 0U /*!< MVFR0: A_SIMD registers bits Position */
|
||||
#define FPU_MVFR0_A_SIMD_registers_Msk (0xFUL /*<< FPU_MVFR0_A_SIMD_registers_Pos*/) /*!< MVFR0: A_SIMD registers bits Mask */
|
||||
|
||||
/* Media and FP Feature Register 1 Definitions */
|
||||
#define FPU_MVFR1_FP_fused_MAC_Pos 28U /*!< MVFR1: FP fused MAC bits Position */
|
||||
#define FPU_MVFR1_FP_fused_MAC_Msk (0xFUL << FPU_MVFR1_FP_fused_MAC_Pos) /*!< MVFR1: FP fused MAC bits Mask */
|
||||
|
||||
#define FPU_MVFR1_FP_HPFP_Pos 24U /*!< MVFR1: FP HPFP bits Position */
|
||||
#define FPU_MVFR1_FP_HPFP_Msk (0xFUL << FPU_MVFR1_FP_HPFP_Pos) /*!< MVFR1: FP HPFP bits Mask */
|
||||
|
||||
#define FPU_MVFR1_D_NaN_mode_Pos 4U /*!< MVFR1: D_NaN mode bits Position */
|
||||
#define FPU_MVFR1_D_NaN_mode_Msk (0xFUL << FPU_MVFR1_D_NaN_mode_Pos) /*!< MVFR1: D_NaN mode bits Mask */
|
||||
|
||||
#define FPU_MVFR1_FtZ_mode_Pos 0U /*!< MVFR1: FtZ mode bits Position */
|
||||
#define FPU_MVFR1_FtZ_mode_Msk (0xFUL /*<< FPU_MVFR1_FtZ_mode_Pos*/) /*!< MVFR1: FtZ mode bits Mask */
|
||||
|
||||
/*@} end of group CMSIS_FPU */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_CoreDebug Core Debug Registers (CoreDebug)
|
||||
\brief Type definitions for the Core Debug Registers
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Structure type to access the Core Debug Register (CoreDebug).
|
||||
*/
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t DHCSR; /*!< Offset: 0x000 (R/W) Debug Halting Control and Status Register */
|
||||
__OM uint32_t DCRSR; /*!< Offset: 0x004 ( /W) Debug Core Register Selector Register */
|
||||
__IOM uint32_t DCRDR; /*!< Offset: 0x008 (R/W) Debug Core Register Data Register */
|
||||
__IOM uint32_t DEMCR; /*!< Offset: 0x00C (R/W) Debug Exception and Monitor Control Register */
|
||||
} CoreDebug_Type;
|
||||
|
||||
/* Debug Halting Control and Status Register Definitions */
|
||||
#define CoreDebug_DHCSR_DBGKEY_Pos 16U /*!< CoreDebug DHCSR: DBGKEY Position */
|
||||
#define CoreDebug_DHCSR_DBGKEY_Msk (0xFFFFUL << CoreDebug_DHCSR_DBGKEY_Pos) /*!< CoreDebug DHCSR: DBGKEY Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_RESET_ST_Pos 25U /*!< CoreDebug DHCSR: S_RESET_ST Position */
|
||||
#define CoreDebug_DHCSR_S_RESET_ST_Msk (1UL << CoreDebug_DHCSR_S_RESET_ST_Pos) /*!< CoreDebug DHCSR: S_RESET_ST Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_RETIRE_ST_Pos 24U /*!< CoreDebug DHCSR: S_RETIRE_ST Position */
|
||||
#define CoreDebug_DHCSR_S_RETIRE_ST_Msk (1UL << CoreDebug_DHCSR_S_RETIRE_ST_Pos) /*!< CoreDebug DHCSR: S_RETIRE_ST Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_LOCKUP_Pos 19U /*!< CoreDebug DHCSR: S_LOCKUP Position */
|
||||
#define CoreDebug_DHCSR_S_LOCKUP_Msk (1UL << CoreDebug_DHCSR_S_LOCKUP_Pos) /*!< CoreDebug DHCSR: S_LOCKUP Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_SLEEP_Pos 18U /*!< CoreDebug DHCSR: S_SLEEP Position */
|
||||
#define CoreDebug_DHCSR_S_SLEEP_Msk (1UL << CoreDebug_DHCSR_S_SLEEP_Pos) /*!< CoreDebug DHCSR: S_SLEEP Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_HALT_Pos 17U /*!< CoreDebug DHCSR: S_HALT Position */
|
||||
#define CoreDebug_DHCSR_S_HALT_Msk (1UL << CoreDebug_DHCSR_S_HALT_Pos) /*!< CoreDebug DHCSR: S_HALT Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_S_REGRDY_Pos 16U /*!< CoreDebug DHCSR: S_REGRDY Position */
|
||||
#define CoreDebug_DHCSR_S_REGRDY_Msk (1UL << CoreDebug_DHCSR_S_REGRDY_Pos) /*!< CoreDebug DHCSR: S_REGRDY Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_C_SNAPSTALL_Pos 5U /*!< CoreDebug DHCSR: C_SNAPSTALL Position */
|
||||
#define CoreDebug_DHCSR_C_SNAPSTALL_Msk (1UL << CoreDebug_DHCSR_C_SNAPSTALL_Pos) /*!< CoreDebug DHCSR: C_SNAPSTALL Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_C_MASKINTS_Pos 3U /*!< CoreDebug DHCSR: C_MASKINTS Position */
|
||||
#define CoreDebug_DHCSR_C_MASKINTS_Msk (1UL << CoreDebug_DHCSR_C_MASKINTS_Pos) /*!< CoreDebug DHCSR: C_MASKINTS Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_C_STEP_Pos 2U /*!< CoreDebug DHCSR: C_STEP Position */
|
||||
#define CoreDebug_DHCSR_C_STEP_Msk (1UL << CoreDebug_DHCSR_C_STEP_Pos) /*!< CoreDebug DHCSR: C_STEP Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_C_HALT_Pos 1U /*!< CoreDebug DHCSR: C_HALT Position */
|
||||
#define CoreDebug_DHCSR_C_HALT_Msk (1UL << CoreDebug_DHCSR_C_HALT_Pos) /*!< CoreDebug DHCSR: C_HALT Mask */
|
||||
|
||||
#define CoreDebug_DHCSR_C_DEBUGEN_Pos 0U /*!< CoreDebug DHCSR: C_DEBUGEN Position */
|
||||
#define CoreDebug_DHCSR_C_DEBUGEN_Msk (1UL /*<< CoreDebug_DHCSR_C_DEBUGEN_Pos*/) /*!< CoreDebug DHCSR: C_DEBUGEN Mask */
|
||||
|
||||
/* Debug Core Register Selector Register Definitions */
|
||||
#define CoreDebug_DCRSR_REGWnR_Pos 16U /*!< CoreDebug DCRSR: REGWnR Position */
|
||||
#define CoreDebug_DCRSR_REGWnR_Msk (1UL << CoreDebug_DCRSR_REGWnR_Pos) /*!< CoreDebug DCRSR: REGWnR Mask */
|
||||
|
||||
#define CoreDebug_DCRSR_REGSEL_Pos 0U /*!< CoreDebug DCRSR: REGSEL Position */
|
||||
#define CoreDebug_DCRSR_REGSEL_Msk (0x1FUL /*<< CoreDebug_DCRSR_REGSEL_Pos*/) /*!< CoreDebug DCRSR: REGSEL Mask */
|
||||
|
||||
/* Debug Exception and Monitor Control Register Definitions */
|
||||
#define CoreDebug_DEMCR_TRCENA_Pos 24U /*!< CoreDebug DEMCR: TRCENA Position */
|
||||
#define CoreDebug_DEMCR_TRCENA_Msk (1UL << CoreDebug_DEMCR_TRCENA_Pos) /*!< CoreDebug DEMCR: TRCENA Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_MON_REQ_Pos 19U /*!< CoreDebug DEMCR: MON_REQ Position */
|
||||
#define CoreDebug_DEMCR_MON_REQ_Msk (1UL << CoreDebug_DEMCR_MON_REQ_Pos) /*!< CoreDebug DEMCR: MON_REQ Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_MON_STEP_Pos 18U /*!< CoreDebug DEMCR: MON_STEP Position */
|
||||
#define CoreDebug_DEMCR_MON_STEP_Msk (1UL << CoreDebug_DEMCR_MON_STEP_Pos) /*!< CoreDebug DEMCR: MON_STEP Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_MON_PEND_Pos 17U /*!< CoreDebug DEMCR: MON_PEND Position */
|
||||
#define CoreDebug_DEMCR_MON_PEND_Msk (1UL << CoreDebug_DEMCR_MON_PEND_Pos) /*!< CoreDebug DEMCR: MON_PEND Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_MON_EN_Pos 16U /*!< CoreDebug DEMCR: MON_EN Position */
|
||||
#define CoreDebug_DEMCR_MON_EN_Msk (1UL << CoreDebug_DEMCR_MON_EN_Pos) /*!< CoreDebug DEMCR: MON_EN Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_HARDERR_Pos 10U /*!< CoreDebug DEMCR: VC_HARDERR Position */
|
||||
#define CoreDebug_DEMCR_VC_HARDERR_Msk (1UL << CoreDebug_DEMCR_VC_HARDERR_Pos) /*!< CoreDebug DEMCR: VC_HARDERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_INTERR_Pos 9U /*!< CoreDebug DEMCR: VC_INTERR Position */
|
||||
#define CoreDebug_DEMCR_VC_INTERR_Msk (1UL << CoreDebug_DEMCR_VC_INTERR_Pos) /*!< CoreDebug DEMCR: VC_INTERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_BUSERR_Pos 8U /*!< CoreDebug DEMCR: VC_BUSERR Position */
|
||||
#define CoreDebug_DEMCR_VC_BUSERR_Msk (1UL << CoreDebug_DEMCR_VC_BUSERR_Pos) /*!< CoreDebug DEMCR: VC_BUSERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_STATERR_Pos 7U /*!< CoreDebug DEMCR: VC_STATERR Position */
|
||||
#define CoreDebug_DEMCR_VC_STATERR_Msk (1UL << CoreDebug_DEMCR_VC_STATERR_Pos) /*!< CoreDebug DEMCR: VC_STATERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_CHKERR_Pos 6U /*!< CoreDebug DEMCR: VC_CHKERR Position */
|
||||
#define CoreDebug_DEMCR_VC_CHKERR_Msk (1UL << CoreDebug_DEMCR_VC_CHKERR_Pos) /*!< CoreDebug DEMCR: VC_CHKERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_NOCPERR_Pos 5U /*!< CoreDebug DEMCR: VC_NOCPERR Position */
|
||||
#define CoreDebug_DEMCR_VC_NOCPERR_Msk (1UL << CoreDebug_DEMCR_VC_NOCPERR_Pos) /*!< CoreDebug DEMCR: VC_NOCPERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_MMERR_Pos 4U /*!< CoreDebug DEMCR: VC_MMERR Position */
|
||||
#define CoreDebug_DEMCR_VC_MMERR_Msk (1UL << CoreDebug_DEMCR_VC_MMERR_Pos) /*!< CoreDebug DEMCR: VC_MMERR Mask */
|
||||
|
||||
#define CoreDebug_DEMCR_VC_CORERESET_Pos 0U /*!< CoreDebug DEMCR: VC_CORERESET Position */
|
||||
#define CoreDebug_DEMCR_VC_CORERESET_Msk (1UL /*<< CoreDebug_DEMCR_VC_CORERESET_Pos*/) /*!< CoreDebug DEMCR: VC_CORERESET Mask */
|
||||
|
||||
/*@} end of group CMSIS_CoreDebug */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_core_bitfield Core register bit field macros
|
||||
\brief Macros for use with bit field definitions (xxx_Pos, xxx_Msk).
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief Mask and shift a bit field value for use in a register bit range.
|
||||
\param[in] field Name of the register bit field.
|
||||
\param[in] value Value of the bit field. This parameter is interpreted as an uint32_t type.
|
||||
\return Masked and shifted value.
|
||||
*/
|
||||
#define _VAL2FLD(field, value) (((uint32_t)(value) << field ## _Pos) & field ## _Msk)
|
||||
|
||||
/**
|
||||
\brief Mask and shift a register value to extract a bit filed value.
|
||||
\param[in] field Name of the register bit field.
|
||||
\param[in] value Value of register. This parameter is interpreted as an uint32_t type.
|
||||
\return Masked and shifted bit field value.
|
||||
*/
|
||||
#define _FLD2VAL(field, value) (((uint32_t)(value) & field ## _Msk) >> field ## _Pos)
|
||||
|
||||
/*@} end of group CMSIS_core_bitfield */
|
||||
|
||||
|
||||
/**
|
||||
\ingroup CMSIS_core_register
|
||||
\defgroup CMSIS_core_base Core Definitions
|
||||
\brief Definitions for base addresses, unions, and structures.
|
||||
@{
|
||||
*/
|
||||
|
||||
/* Memory mapping of Core Hardware */
|
||||
#define SCS_BASE (0xE000E000UL) /*!< System Control Space Base Address */
|
||||
#define ITM_BASE (0xE0000000UL) /*!< ITM Base Address */
|
||||
#define DWT_BASE (0xE0001000UL) /*!< DWT Base Address */
|
||||
#define TPI_BASE (0xE0040000UL) /*!< TPI Base Address */
|
||||
#define CoreDebug_BASE (0xE000EDF0UL) /*!< Core Debug Base Address */
|
||||
#define SysTick_BASE (SCS_BASE + 0x0010UL) /*!< SysTick Base Address */
|
||||
#define NVIC_BASE (SCS_BASE + 0x0100UL) /*!< NVIC Base Address */
|
||||
#define SCB_BASE (SCS_BASE + 0x0D00UL) /*!< System Control Block Base Address */
|
||||
|
||||
#define SCnSCB ((SCnSCB_Type *) SCS_BASE ) /*!< System control Register not in SCB */
|
||||
#define SCB ((SCB_Type *) SCB_BASE ) /*!< SCB configuration struct */
|
||||
#define SysTick ((SysTick_Type *) SysTick_BASE ) /*!< SysTick configuration struct */
|
||||
#define NVIC ((NVIC_Type *) NVIC_BASE ) /*!< NVIC configuration struct */
|
||||
#define ITM ((ITM_Type *) ITM_BASE ) /*!< ITM configuration struct */
|
||||
#define DWT ((DWT_Type *) DWT_BASE ) /*!< DWT configuration struct */
|
||||
#define TPI ((TPI_Type *) TPI_BASE ) /*!< TPI configuration struct */
|
||||
#define CoreDebug ((CoreDebug_Type *) CoreDebug_BASE) /*!< Core Debug configuration struct */
|
||||
|
||||
#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
|
||||
#define MPU_BASE (SCS_BASE + 0x0D90UL) /*!< Memory Protection Unit */
|
||||
#define MPU ((MPU_Type *) MPU_BASE ) /*!< Memory Protection Unit */
|
||||
#endif
|
||||
|
||||
#define FPU_BASE (SCS_BASE + 0x0F30UL) /*!< Floating Point Unit */
|
||||
#define FPU ((FPU_Type *) FPU_BASE ) /*!< Floating Point Unit */
|
||||
|
||||
/*@} */
|
||||
|
||||
|
||||
|
||||
/*******************************************************************************
|
||||
* Hardware Abstraction Layer
|
||||
Core Function Interface contains:
|
||||
- Core NVIC Functions
|
||||
- Core SysTick Functions
|
||||
- Core Debug Functions
|
||||
- Core Register Access Functions
|
||||
******************************************************************************/
|
||||
/**
|
||||
\defgroup CMSIS_Core_FunctionInterface Functions and Instructions Reference
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/* ########################## NVIC functions #################################### */
|
||||
/**
|
||||
\ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_NVICFunctions NVIC Functions
|
||||
\brief Functions that manage interrupts and exceptions via the NVIC.
|
||||
@{
|
||||
*/
|
||||
|
||||
#ifdef CMSIS_NVIC_VIRTUAL
|
||||
#ifndef CMSIS_NVIC_VIRTUAL_HEADER_FILE
|
||||
#define CMSIS_NVIC_VIRTUAL_HEADER_FILE "cmsis_nvic_virtual.h"
|
||||
#endif
|
||||
#include CMSIS_NVIC_VIRTUAL_HEADER_FILE
|
||||
#else
|
||||
#define NVIC_SetPriorityGrouping __NVIC_SetPriorityGrouping
|
||||
#define NVIC_GetPriorityGrouping __NVIC_GetPriorityGrouping
|
||||
#define NVIC_EnableIRQ __NVIC_EnableIRQ
|
||||
#define NVIC_GetEnableIRQ __NVIC_GetEnableIRQ
|
||||
#define NVIC_DisableIRQ __NVIC_DisableIRQ
|
||||
#define NVIC_GetPendingIRQ __NVIC_GetPendingIRQ
|
||||
#define NVIC_SetPendingIRQ __NVIC_SetPendingIRQ
|
||||
#define NVIC_ClearPendingIRQ __NVIC_ClearPendingIRQ
|
||||
#define NVIC_GetActive __NVIC_GetActive
|
||||
#define NVIC_SetPriority __NVIC_SetPriority
|
||||
#define NVIC_GetPriority __NVIC_GetPriority
|
||||
#define NVIC_SystemReset __NVIC_SystemReset
|
||||
#endif /* CMSIS_NVIC_VIRTUAL */
|
||||
|
||||
#ifdef CMSIS_VECTAB_VIRTUAL
|
||||
#ifndef CMSIS_VECTAB_VIRTUAL_HEADER_FILE
|
||||
#define CMSIS_VECTAB_VIRTUAL_HEADER_FILE "cmsis_vectab_virtual.h"
|
||||
#endif
|
||||
#include CMSIS_VECTAB_VIRTUAL_HEADER_FILE
|
||||
#else
|
||||
#define NVIC_SetVector __NVIC_SetVector
|
||||
#define NVIC_GetVector __NVIC_GetVector
|
||||
#endif /* (CMSIS_VECTAB_VIRTUAL) */
|
||||
|
||||
#define NVIC_USER_IRQ_OFFSET 16
|
||||
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Priority Grouping
|
||||
\details Sets the priority grouping field using the required unlock sequence.
|
||||
The parameter PriorityGroup is assigned to the field SCB->AIRCR [10:8] PRIGROUP field.
|
||||
Only values from 0..7 are used.
|
||||
In case of a conflict between priority grouping and available
|
||||
priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
|
||||
\param [in] PriorityGroup Priority grouping field.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
|
||||
{
|
||||
uint32_t reg_value;
|
||||
uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */
|
||||
|
||||
reg_value = SCB->AIRCR; /* read old register configuration */
|
||||
reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */
|
||||
reg_value = (reg_value |
|
||||
((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
|
||||
(PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */
|
||||
SCB->AIRCR = reg_value;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Priority Grouping
|
||||
\details Reads the priority grouping field from the NVIC Interrupt Controller.
|
||||
\return Priority grouping field (SCB->AIRCR [10:8] PRIGROUP field).
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetPriorityGrouping(void)
|
||||
{
|
||||
return ((uint32_t)((SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) >> SCB_AIRCR_PRIGROUP_Pos));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Enable Interrupt
|
||||
\details Enables a device specific interrupt in the NVIC interrupt controller.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_EnableIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Interrupt Enable status
|
||||
\details Returns a device specific interrupt enable status from the NVIC interrupt controller.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\return 0 Interrupt is not enabled.
|
||||
\return 1 Interrupt is enabled.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetEnableIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
return((uint32_t)(((NVIC->ISER[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
|
||||
}
|
||||
else
|
||||
{
|
||||
return(0U);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Disable Interrupt
|
||||
\details Disables a device specific interrupt in the NVIC interrupt controller.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_DisableIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
NVIC->ICER[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
|
||||
__DSB();
|
||||
__ISB();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Pending Interrupt
|
||||
\details Reads the NVIC pending register and returns the pending bit for the specified device specific interrupt.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\return 0 Interrupt status is not pending.
|
||||
\return 1 Interrupt status is pending.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetPendingIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
return((uint32_t)(((NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
|
||||
}
|
||||
else
|
||||
{
|
||||
return(0U);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Pending Interrupt
|
||||
\details Sets the pending bit of a device specific interrupt in the NVIC pending register.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_SetPendingIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
NVIC->ISPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Clear Pending Interrupt
|
||||
\details Clears the pending bit of a device specific interrupt in the NVIC pending register.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_ClearPendingIRQ(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
NVIC->ICPR[(((uint32_t)(int32_t)IRQn) >> 5UL)] = (uint32_t)(1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Active Interrupt
|
||||
\details Reads the active register in the NVIC and returns the active bit for the device specific interrupt.
|
||||
\param [in] IRQn Device specific interrupt number.
|
||||
\return 0 Interrupt status is not active.
|
||||
\return 1 Interrupt status is active.
|
||||
\note IRQn must not be negative.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetActive(IRQn_Type IRQn)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
return((uint32_t)(((NVIC->IABR[(((uint32_t)(int32_t)IRQn) >> 5UL)] & (1UL << (((uint32_t)(int32_t)IRQn) & 0x1FUL))) != 0UL) ? 1UL : 0UL));
|
||||
}
|
||||
else
|
||||
{
|
||||
return(0U);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Interrupt Priority
|
||||
\details Sets the priority of a device specific interrupt or a processor exception.
|
||||
The interrupt number can be positive to specify a device specific interrupt,
|
||||
or negative to specify a processor exception.
|
||||
\param [in] IRQn Interrupt number.
|
||||
\param [in] priority Priority to set.
|
||||
\note The priority cannot be set for every processor exception.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_SetPriority(IRQn_Type IRQn, uint32_t priority)
|
||||
{
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
NVIC->IP[((uint32_t)(int32_t)IRQn)] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
|
||||
}
|
||||
else
|
||||
{
|
||||
SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] = (uint8_t)((priority << (8U - __NVIC_PRIO_BITS)) & (uint32_t)0xFFUL);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Interrupt Priority
|
||||
\details Reads the priority of a device specific interrupt or a processor exception.
|
||||
The interrupt number can be positive to specify a device specific interrupt,
|
||||
or negative to specify a processor exception.
|
||||
\param [in] IRQn Interrupt number.
|
||||
\return Interrupt Priority.
|
||||
Value is aligned automatically to the implemented priority bits of the microcontroller.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetPriority(IRQn_Type IRQn)
|
||||
{
|
||||
|
||||
if ((int32_t)(IRQn) >= 0)
|
||||
{
|
||||
return(((uint32_t)NVIC->IP[((uint32_t)(int32_t)IRQn)] >> (8U - __NVIC_PRIO_BITS)));
|
||||
}
|
||||
else
|
||||
{
|
||||
return(((uint32_t)SCB->SHP[(((uint32_t)(int32_t)IRQn) & 0xFUL)-4UL] >> (8U - __NVIC_PRIO_BITS)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Encode Priority
|
||||
\details Encodes the priority for an interrupt with the given priority group,
|
||||
preemptive priority value, and subpriority value.
|
||||
In case of a conflict between priority grouping and available
|
||||
priority bits (__NVIC_PRIO_BITS), the smallest possible priority group is set.
|
||||
\param [in] PriorityGroup Used priority group.
|
||||
\param [in] PreemptPriority Preemptive priority value (starting from 0).
|
||||
\param [in] SubPriority Subpriority value (starting from 0).
|
||||
\return Encoded priority. Value can be used in the function \ref NVIC_SetPriority().
|
||||
*/
|
||||
__STATIC_INLINE uint32_t NVIC_EncodePriority (uint32_t PriorityGroup, uint32_t PreemptPriority, uint32_t SubPriority)
|
||||
{
|
||||
uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */
|
||||
uint32_t PreemptPriorityBits;
|
||||
uint32_t SubPriorityBits;
|
||||
|
||||
PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
|
||||
SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
|
||||
|
||||
return (
|
||||
((PreemptPriority & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL)) << SubPriorityBits) |
|
||||
((SubPriority & (uint32_t)((1UL << (SubPriorityBits )) - 1UL)))
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Decode Priority
|
||||
\details Decodes an interrupt priority value with a given priority group to
|
||||
preemptive priority value and subpriority value.
|
||||
In case of a conflict between priority grouping and available
|
||||
priority bits (__NVIC_PRIO_BITS) the smallest possible priority group is set.
|
||||
\param [in] Priority Priority value, which can be retrieved with the function \ref NVIC_GetPriority().
|
||||
\param [in] PriorityGroup Used priority group.
|
||||
\param [out] pPreemptPriority Preemptive priority value (starting from 0).
|
||||
\param [out] pSubPriority Subpriority value (starting from 0).
|
||||
*/
|
||||
__STATIC_INLINE void NVIC_DecodePriority (uint32_t Priority, uint32_t PriorityGroup, uint32_t* const pPreemptPriority, uint32_t* const pSubPriority)
|
||||
{
|
||||
uint32_t PriorityGroupTmp = (PriorityGroup & (uint32_t)0x07UL); /* only values 0..7 are used */
|
||||
uint32_t PreemptPriorityBits;
|
||||
uint32_t SubPriorityBits;
|
||||
|
||||
PreemptPriorityBits = ((7UL - PriorityGroupTmp) > (uint32_t)(__NVIC_PRIO_BITS)) ? (uint32_t)(__NVIC_PRIO_BITS) : (uint32_t)(7UL - PriorityGroupTmp);
|
||||
SubPriorityBits = ((PriorityGroupTmp + (uint32_t)(__NVIC_PRIO_BITS)) < (uint32_t)7UL) ? (uint32_t)0UL : (uint32_t)((PriorityGroupTmp - 7UL) + (uint32_t)(__NVIC_PRIO_BITS));
|
||||
|
||||
*pPreemptPriority = (Priority >> SubPriorityBits) & (uint32_t)((1UL << (PreemptPriorityBits)) - 1UL);
|
||||
*pSubPriority = (Priority ) & (uint32_t)((1UL << (SubPriorityBits )) - 1UL);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Set Interrupt Vector
|
||||
\details Sets an interrupt vector in SRAM based interrupt vector table.
|
||||
The interrupt number can be positive to specify a device specific interrupt,
|
||||
or negative to specify a processor exception.
|
||||
VTOR must been relocated to SRAM before.
|
||||
\param [in] IRQn Interrupt number
|
||||
\param [in] vector Address of interrupt handler function
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_SetVector(IRQn_Type IRQn, uint32_t vector)
|
||||
{
|
||||
uint32_t *vectors = (uint32_t *)SCB->VTOR;
|
||||
vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET] = vector;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief Get Interrupt Vector
|
||||
\details Reads an interrupt vector from interrupt vector table.
|
||||
The interrupt number can be positive to specify a device specific interrupt,
|
||||
or negative to specify a processor exception.
|
||||
\param [in] IRQn Interrupt number.
|
||||
\return Address of interrupt handler function
|
||||
*/
|
||||
__STATIC_INLINE uint32_t __NVIC_GetVector(IRQn_Type IRQn)
|
||||
{
|
||||
uint32_t *vectors = (uint32_t *)SCB->VTOR;
|
||||
return vectors[(int32_t)IRQn + NVIC_USER_IRQ_OFFSET];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief System Reset
|
||||
\details Initiates a system reset request to reset the MCU.
|
||||
*/
|
||||
__STATIC_INLINE void __NVIC_SystemReset(void)
|
||||
{
|
||||
__DSB(); /* Ensure all outstanding memory accesses included
|
||||
buffered write are completed before reset */
|
||||
SCB->AIRCR = (uint32_t)((0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
|
||||
(SCB->AIRCR & SCB_AIRCR_PRIGROUP_Msk) |
|
||||
SCB_AIRCR_SYSRESETREQ_Msk ); /* Keep priority group unchanged */
|
||||
__DSB(); /* Ensure completion of memory access */
|
||||
|
||||
for(;;) /* wait until reset */
|
||||
{
|
||||
__NOP();
|
||||
}
|
||||
}
|
||||
|
||||
/*@} end of CMSIS_Core_NVICFunctions */
|
||||
|
||||
/* ########################## MPU functions #################################### */
|
||||
|
||||
#if defined (__MPU_PRESENT) && (__MPU_PRESENT == 1U)
|
||||
|
||||
#include "mpu_armv7.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* ########################## FPU functions #################################### */
|
||||
/**
|
||||
\ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_FpuFunctions FPU Functions
|
||||
\brief Function that provides FPU type.
|
||||
@{
|
||||
*/
|
||||
|
||||
/**
|
||||
\brief get FPU type
|
||||
\details returns the FPU type
|
||||
\returns
|
||||
- \b 0: No FPU
|
||||
- \b 1: Single precision FPU
|
||||
- \b 2: Double + Single precision FPU
|
||||
*/
|
||||
__STATIC_INLINE uint32_t SCB_GetFPUType(void)
|
||||
{
|
||||
uint32_t mvfr0;
|
||||
|
||||
mvfr0 = FPU->MVFR0;
|
||||
if ((mvfr0 & (FPU_MVFR0_Single_precision_Msk | FPU_MVFR0_Double_precision_Msk)) == 0x020U)
|
||||
{
|
||||
return 1U; /* Single precision FPU */
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0U; /* No FPU */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*@} end of CMSIS_Core_FpuFunctions */
|
||||
|
||||
|
||||
|
||||
/* ################################## SysTick function ############################################ */
|
||||
/**
|
||||
\ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_Core_SysTickFunctions SysTick Functions
|
||||
\brief Functions that configure the System.
|
||||
@{
|
||||
*/
|
||||
|
||||
#if defined (__Vendor_SysTickConfig) && (__Vendor_SysTickConfig == 0U)
|
||||
|
||||
/**
|
||||
\brief System Tick Configuration
|
||||
\details Initializes the System Timer and its interrupt, and starts the System Tick Timer.
|
||||
Counter is in free running mode to generate periodic interrupts.
|
||||
\param [in] ticks Number of ticks between two interrupts.
|
||||
\return 0 Function succeeded.
|
||||
\return 1 Function failed.
|
||||
\note When the variable <b>__Vendor_SysTickConfig</b> is set to 1, then the
|
||||
function <b>SysTick_Config</b> is not included. In this case, the file <b><i>device</i>.h</b>
|
||||
must contain a vendor-specific implementation of this function.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t SysTick_Config(uint32_t ticks)
|
||||
{
|
||||
if ((ticks - 1UL) > SysTick_LOAD_RELOAD_Msk)
|
||||
{
|
||||
return (1UL); /* Reload value impossible */
|
||||
}
|
||||
|
||||
SysTick->LOAD = (uint32_t)(ticks - 1UL); /* set reload register */
|
||||
NVIC_SetPriority (SysTick_IRQn, (1UL << __NVIC_PRIO_BITS) - 1UL); /* set Priority for Systick Interrupt */
|
||||
SysTick->VAL = 0UL; /* Load the SysTick Counter Value */
|
||||
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
|
||||
SysTick_CTRL_TICKINT_Msk |
|
||||
SysTick_CTRL_ENABLE_Msk; /* Enable SysTick IRQ and SysTick Timer */
|
||||
return (0UL); /* Function successful */
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
/*@} end of CMSIS_Core_SysTickFunctions */
|
||||
|
||||
|
||||
|
||||
/* ##################################### Debug In/Output function ########################################### */
|
||||
/**
|
||||
\ingroup CMSIS_Core_FunctionInterface
|
||||
\defgroup CMSIS_core_DebugFunctions ITM Functions
|
||||
\brief Functions that access the ITM debug interface.
|
||||
@{
|
||||
*/
|
||||
|
||||
extern volatile int32_t ITM_RxBuffer; /*!< External variable to receive characters. */
|
||||
#define ITM_RXBUFFER_EMPTY ((int32_t)0x5AA55AA5U) /*!< Value identifying \ref ITM_RxBuffer is ready for next character. */
|
||||
|
||||
|
||||
/**
|
||||
\brief ITM Send Character
|
||||
\details Transmits a character via the ITM channel 0, and
|
||||
\li Just returns when no debugger is connected that has booked the output.
|
||||
\li Is blocking when a debugger is connected, but the previous character sent has not been transmitted.
|
||||
\param [in] ch Character to transmit.
|
||||
\returns Character to transmit.
|
||||
*/
|
||||
__STATIC_INLINE uint32_t ITM_SendChar (uint32_t ch)
|
||||
{
|
||||
if (((ITM->TCR & ITM_TCR_ITMENA_Msk) != 0UL) && /* ITM enabled */
|
||||
((ITM->TER & 1UL ) != 0UL) ) /* ITM Port #0 enabled */
|
||||
{
|
||||
while (ITM->PORT[0U].u32 == 0UL)
|
||||
{
|
||||
__NOP();
|
||||
}
|
||||
ITM->PORT[0U].u8 = (uint8_t)ch;
|
||||
}
|
||||
return (ch);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief ITM Receive Character
|
||||
\details Inputs a character via the external variable \ref ITM_RxBuffer.
|
||||
\return Received character.
|
||||
\return -1 No character pending.
|
||||
*/
|
||||
__STATIC_INLINE int32_t ITM_ReceiveChar (void)
|
||||
{
|
||||
int32_t ch = -1; /* no character available */
|
||||
|
||||
if (ITM_RxBuffer != ITM_RXBUFFER_EMPTY)
|
||||
{
|
||||
ch = ITM_RxBuffer;
|
||||
ITM_RxBuffer = ITM_RXBUFFER_EMPTY; /* ready for next character */
|
||||
}
|
||||
|
||||
return (ch);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
\brief ITM Check Character
|
||||
\details Checks whether a character is pending for reading in the variable \ref ITM_RxBuffer.
|
||||
\return 0 No character available.
|
||||
\return 1 Character available.
|
||||
*/
|
||||
__STATIC_INLINE int32_t ITM_CheckChar (void)
|
||||
{
|
||||
|
||||
if (ITM_RxBuffer == ITM_RXBUFFER_EMPTY)
|
||||
{
|
||||
return (0); /* no character available */
|
||||
}
|
||||
else
|
||||
{
|
||||
return (1); /* character available */
|
||||
}
|
||||
}
|
||||
|
||||
/*@} end of CMSIS_core_DebugFunctions */
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __CORE_CM4_H_DEPENDANT */
|
||||
|
||||
#endif /* __CMSIS_GENERIC */
|
||||
204
MDK-ARM/platform/CMSIS/Core/Include/mpu_armv7.h
Normal file
204
MDK-ARM/platform/CMSIS/Core/Include/mpu_armv7.h
Normal file
@@ -0,0 +1,204 @@
|
||||
/******************************************************************************
|
||||
* @file mpu_armv7.h
|
||||
* @brief CMSIS MPU API for ARMv7 MPU
|
||||
* @version V5.0.3
|
||||
* @date 09. August 2017
|
||||
******************************************************************************/
|
||||
/*
|
||||
* Copyright (c) 2017 ARM Limited. All rights reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the License); you may
|
||||
* not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#if defined ( __ICCARM__ )
|
||||
#pragma system_include /* treat file as system include file for MISRA check */
|
||||
#elif defined (__clang__)
|
||||
#pragma clang system_header /* treat file as system include file */
|
||||
#endif
|
||||
|
||||
#ifndef ARM_MPU_ARMV7_H
|
||||
#define ARM_MPU_ARMV7_H
|
||||
|
||||
#define ARM_MPU_REGION_SIZE_32B ((uint8_t)0x04U)
|
||||
#define ARM_MPU_REGION_SIZE_64B ((uint8_t)0x05U)
|
||||
#define ARM_MPU_REGION_SIZE_128B ((uint8_t)0x06U)
|
||||
#define ARM_MPU_REGION_SIZE_256B ((uint8_t)0x07U)
|
||||
#define ARM_MPU_REGION_SIZE_512B ((uint8_t)0x08U)
|
||||
#define ARM_MPU_REGION_SIZE_1KB ((uint8_t)0x09U)
|
||||
#define ARM_MPU_REGION_SIZE_2KB ((uint8_t)0x0AU)
|
||||
#define ARM_MPU_REGION_SIZE_4KB ((uint8_t)0x0BU)
|
||||
#define ARM_MPU_REGION_SIZE_8KB ((uint8_t)0x0CU)
|
||||
#define ARM_MPU_REGION_SIZE_16KB ((uint8_t)0x0DU)
|
||||
#define ARM_MPU_REGION_SIZE_32KB ((uint8_t)0x0EU)
|
||||
#define ARM_MPU_REGION_SIZE_64KB ((uint8_t)0x0FU)
|
||||
#define ARM_MPU_REGION_SIZE_128KB ((uint8_t)0x10U)
|
||||
#define ARM_MPU_REGION_SIZE_256KB ((uint8_t)0x11U)
|
||||
#define ARM_MPU_REGION_SIZE_512KB ((uint8_t)0x12U)
|
||||
#define ARM_MPU_REGION_SIZE_1MB ((uint8_t)0x13U)
|
||||
#define ARM_MPU_REGION_SIZE_2MB ((uint8_t)0x14U)
|
||||
#define ARM_MPU_REGION_SIZE_4MB ((uint8_t)0x15U)
|
||||
#define ARM_MPU_REGION_SIZE_8MB ((uint8_t)0x16U)
|
||||
#define ARM_MPU_REGION_SIZE_16MB ((uint8_t)0x17U)
|
||||
#define ARM_MPU_REGION_SIZE_32MB ((uint8_t)0x18U)
|
||||
#define ARM_MPU_REGION_SIZE_64MB ((uint8_t)0x19U)
|
||||
#define ARM_MPU_REGION_SIZE_128MB ((uint8_t)0x1AU)
|
||||
#define ARM_MPU_REGION_SIZE_256MB ((uint8_t)0x1BU)
|
||||
#define ARM_MPU_REGION_SIZE_512MB ((uint8_t)0x1CU)
|
||||
#define ARM_MPU_REGION_SIZE_1GB ((uint8_t)0x1DU)
|
||||
#define ARM_MPU_REGION_SIZE_2GB ((uint8_t)0x1EU)
|
||||
#define ARM_MPU_REGION_SIZE_4GB ((uint8_t)0x1FU)
|
||||
|
||||
#define ARM_MPU_AP_NONE 0U
|
||||
#define ARM_MPU_AP_PRIV 1U
|
||||
#define ARM_MPU_AP_URO 2U
|
||||
#define ARM_MPU_AP_FULL 3U
|
||||
#define ARM_MPU_AP_PRO 5U
|
||||
#define ARM_MPU_AP_RO 6U
|
||||
|
||||
/** MPU Region Base Address Register Value
|
||||
*
|
||||
* \param Region The region to be configured, number 0 to 15.
|
||||
* \param BaseAddress The base address for the region.
|
||||
*/
|
||||
#define ARM_MPU_RBAR(Region, BaseAddress) \
|
||||
(((BaseAddress) & MPU_RBAR_ADDR_Msk) | \
|
||||
((Region) & MPU_RBAR_REGION_Msk) | \
|
||||
(MPU_RBAR_VALID_Msk))
|
||||
|
||||
/**
|
||||
* MPU Region Attribut and Size Register Value
|
||||
*
|
||||
* \param DisableExec Instruction access disable bit, 1= disable instruction fetches.
|
||||
* \param AccessPermission Data access permissions, allows you to configure read/write access for User and Privileged mode.
|
||||
* \param TypeExtField Type extension field, allows you to configure memory access type, for example strongly ordered, peripheral.
|
||||
* \param IsShareable Region is shareable between multiple bus masters.
|
||||
* \param IsCacheable Region is cacheable, i.e. its value may be kept in cache.
|
||||
* \param IsBufferable Region is bufferable, i.e. using write-back caching. Cacheable but non-bufferable regions use write-through policy.
|
||||
* \param SubRegionDisable Sub-region disable field.
|
||||
* \param Size Region size of the region to be configured, for example 4K, 8K.
|
||||
*/
|
||||
#define ARM_MPU_RASR(DisableExec, AccessPermission, TypeExtField, IsShareable, IsCacheable, IsBufferable, SubRegionDisable, Size) \
|
||||
((((DisableExec ) << MPU_RASR_XN_Pos) & MPU_RASR_XN_Msk) | \
|
||||
(((AccessPermission) << MPU_RASR_AP_Pos) & MPU_RASR_AP_Msk) | \
|
||||
(((TypeExtField ) << MPU_RASR_TEX_Pos) & MPU_RASR_TEX_Msk) | \
|
||||
(((IsShareable ) << MPU_RASR_S_Pos) & MPU_RASR_S_Msk) | \
|
||||
(((IsCacheable ) << MPU_RASR_C_Pos) & MPU_RASR_C_Msk) | \
|
||||
(((IsBufferable ) << MPU_RASR_B_Pos) & MPU_RASR_B_Msk) | \
|
||||
(((SubRegionDisable) << MPU_RASR_SRD_Pos) & MPU_RASR_SRD_Msk) | \
|
||||
(((Size ) << MPU_RASR_SIZE_Pos) & MPU_RASR_SIZE_Msk) | \
|
||||
(MPU_RASR_ENABLE_Msk))
|
||||
|
||||
|
||||
/**
|
||||
* Struct for a single MPU Region
|
||||
*/
|
||||
#if defined (__CMCPPARM__)
|
||||
typedef struct {
|
||||
uint32_t RBAR; //!< The region base address register value (RBAR)
|
||||
uint32_t RASR; //!< The region attribute and size register value (RASR) \ref MPU_RASR
|
||||
} ARM_MPU_Region_t;
|
||||
#else
|
||||
typedef struct _ARM_MPU_Region_t {
|
||||
uint32_t RBAR; //!< The region base address register value (RBAR)
|
||||
uint32_t RASR; //!< The region attribute and size register value (RASR) \ref MPU_RASR
|
||||
} ARM_MPU_Region_t;
|
||||
#endif
|
||||
|
||||
/** Enable the MPU.
|
||||
* \param MPU_Control Default access permissions for unconfigured regions.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_Enable(uint32_t MPU_Control)
|
||||
{
|
||||
__DSB();
|
||||
__ISB();
|
||||
MPU->CTRL = MPU_Control | MPU_CTRL_ENABLE_Msk;
|
||||
#ifdef SCB_SHCSR_MEMFAULTENA_Msk
|
||||
SCB->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
|
||||
#endif
|
||||
}
|
||||
|
||||
/** Disable the MPU.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_Disable(void)
|
||||
{
|
||||
__DSB();
|
||||
__ISB();
|
||||
#ifdef SCB_SHCSR_MEMFAULTENA_Msk
|
||||
SCB->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
|
||||
#endif
|
||||
MPU->CTRL &= ~MPU_CTRL_ENABLE_Msk;
|
||||
}
|
||||
|
||||
/** Clear and disable the given MPU region.
|
||||
* \param rnr Region number to be cleared.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_ClrRegion(uint32_t rnr)
|
||||
{
|
||||
MPU->RNR = rnr;
|
||||
MPU->RASR = 0U;
|
||||
}
|
||||
|
||||
/** Configure an MPU region.
|
||||
* \param rbar Value for RBAR register.
|
||||
* \param rsar Value for RSAR register.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_SetRegion(uint32_t rbar, uint32_t rasr)
|
||||
{
|
||||
MPU->RBAR = rbar;
|
||||
MPU->RASR = rasr;
|
||||
}
|
||||
|
||||
/** Configure the given MPU region.
|
||||
* \param rnr Region number to be configured.
|
||||
* \param rbar Value for RBAR register.
|
||||
* \param rsar Value for RSAR register.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_SetRegionEx(uint32_t rnr, uint32_t rbar, uint32_t rasr)
|
||||
{
|
||||
MPU->RNR = rnr;
|
||||
MPU->RBAR = rbar;
|
||||
MPU->RASR = rasr;
|
||||
}
|
||||
|
||||
/** Memcopy with strictly ordered memory access, e.g. for register targets.
|
||||
* \param dst Destination data is copied to.
|
||||
* \param src Source data is copied from.
|
||||
* \param len Amount of data words to be copied.
|
||||
*/
|
||||
__STATIC_INLINE void orderedCpy(volatile uint32_t* dst, const uint32_t* __RESTRICT src, uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
for (i = 0U; i < len; ++i)
|
||||
{
|
||||
dst[i] = src[i];
|
||||
}
|
||||
}
|
||||
|
||||
/** Load the given number of MPU regions from a table.
|
||||
* \param table Pointer to the MPU configuration table.
|
||||
* \param cnt Amount of regions to be configured.
|
||||
*/
|
||||
__STATIC_INLINE void ARM_MPU_Load(ARM_MPU_Region_t const* table, uint32_t cnt)
|
||||
{
|
||||
const uint32_t rowWordSize = sizeof(ARM_MPU_Region_t)/4U;
|
||||
while (cnt > MPU_TYPE_RALIASES) {
|
||||
orderedCpy(&(MPU->RBAR), &(table->RBAR), MPU_TYPE_RALIASES*rowWordSize);
|
||||
table += MPU_TYPE_RALIASES;
|
||||
cnt -= MPU_TYPE_RALIASES;
|
||||
}
|
||||
orderedCpy(&(MPU->RBAR), &(table->RBAR), cnt*rowWordSize);
|
||||
}
|
||||
|
||||
#endif
|
||||
10223
MDK-ARM/platform/Device/NIIET/K1921VK035/Include/K1921VK035.h
Normal file
10223
MDK-ARM/platform/Device/NIIET/K1921VK035/Include/K1921VK035.h
Normal file
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,51 @@
|
||||
/*==============================================================================
|
||||
* Инициализация К1921ВК035
|
||||
*------------------------------------------------------------------------------
|
||||
* НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*==============================================================================
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* 2018 АО "НИИЭТ"
|
||||
*==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef SYSTEM_K1921VK035_H
|
||||
#define SYSTEM_K1921VK035_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include <stdint.h>
|
||||
|
||||
//-- Defines -------------------------------------------------------------------
|
||||
#define SYSCLK_OSI // Тактирование при старте системы
|
||||
#define OSICLK_VAL 8000000 // Частота внутреннего кварца
|
||||
#define OSECLK_VAL 24000000 // Частота внешнего кварца
|
||||
|
||||
#define OSECLK_STARTUP_TIMEOUT 0x100000
|
||||
#define SYSCLK_SWITCH_TIMEOUT 0x100000
|
||||
|
||||
//-- Variables -----------------------------------------------------------------
|
||||
extern uint32_t SystemCoreClock; // System Clock Frequency (Core Clock)
|
||||
//-- Functions -----------------------------------------------------------------
|
||||
// Initialize the System
|
||||
extern void SystemInit(void);
|
||||
// Updates the SystemCoreClock with current core Clock retrieved from registers
|
||||
extern void SystemCoreClockUpdate(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // SYSTEM_K1921VK035_H
|
||||
@@ -0,0 +1,393 @@
|
||||
;******************** (C) COPYRIGHT 2018 NIIET ********************
|
||||
;* File Name : startup_K1921VK035.s
|
||||
;* Author : NIIET
|
||||
;* Version : V1.7
|
||||
;* Date : 02.05.2018
|
||||
;* Description : K1921VK035 vector table for MDK-ARM
|
||||
;* toolchain.
|
||||
;* This module performs:
|
||||
;* - Set the initial SP
|
||||
;* - Set the initial PC == Reset_Handler
|
||||
;* - Set the vector table entries with the exceptions ISR address
|
||||
;* - Configure the clock system
|
||||
;* - Branches to __main in the C library (which eventually
|
||||
;* calls main()).
|
||||
;* After Reset the CortexM4 processor is in Thread mode,
|
||||
;* priority is Privileged, and the Stack is set to Main.
|
||||
;* <<< Use Configuration Wizard in Context Menu >>>
|
||||
;*******************************************************************************
|
||||
; THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
|
||||
; WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
|
||||
; AS A RESULT, NIIET SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
|
||||
; INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
|
||||
; CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
|
||||
; INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
|
||||
;*******************************************************************************
|
||||
|
||||
; Amount of memory (in bytes) allocated for Stack
|
||||
; Tailor this value to your application needs
|
||||
; <h> Stack Configuration
|
||||
; <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
|
||||
; </h>
|
||||
|
||||
Stack_Size EQU 0x00000400
|
||||
|
||||
AREA STACK, NOINIT, READWRITE, ALIGN=3
|
||||
Stack_Mem SPACE Stack_Size
|
||||
__initial_sp
|
||||
|
||||
|
||||
; <h> Heap Configuration
|
||||
; <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
|
||||
; </h>
|
||||
|
||||
Heap_Size EQU 0x00000200
|
||||
|
||||
AREA HEAP, NOINIT, READWRITE, ALIGN=3
|
||||
__heap_base
|
||||
Heap_Mem SPACE Heap_Size
|
||||
__heap_limit
|
||||
|
||||
PRESERVE8
|
||||
THUMB
|
||||
|
||||
|
||||
; Vector Table Mapped to Address 0 at Reset
|
||||
AREA RESET, DATA, READONLY
|
||||
EXPORT __Vectors
|
||||
EXPORT __Vectors_End
|
||||
EXPORT __Vectors_Size
|
||||
|
||||
__Vectors DCD __initial_sp ; Top of Stack
|
||||
DCD Reset_Handler ; Reset Handler
|
||||
DCD NMI_Handler ; NMI Handler
|
||||
DCD HardFault_Handler ; Hard Fault Handler
|
||||
DCD MemManage_Handler ; MPU Fault Handler
|
||||
DCD BusFault_Handler ; Bus Fault Handler
|
||||
DCD UsageFault_Handler ; Usage Fault Handler
|
||||
DCD 0 ; Reserved
|
||||
DCD 0 ; Reserved
|
||||
DCD 0 ; Reserved
|
||||
DCD 0 ; Reserved
|
||||
DCD SVC_Handler ; SVCall Handler
|
||||
DCD DebugMon_Handler ; Debug Monitor Handler
|
||||
DCD 0 ; Reserved
|
||||
DCD PendSV_Handler ; PendSV Handler
|
||||
DCD SysTick_Handler ; SysTick Handler
|
||||
|
||||
; External Interrupts
|
||||
DCD WDT_IRQHandler ; Watchdog timer interrupt
|
||||
DCD RCU_IRQHandler ; Reset and clock unit interrupt
|
||||
DCD MFLASH_IRQHandler ; MFLASH interrupt
|
||||
DCD GPIOA_IRQHandler ; GPIO A interrupt
|
||||
DCD GPIOB_IRQHandler ; GPIO B interrupt
|
||||
DCD DMA_CH0_IRQHandler ; DMA channel 0 interrupt
|
||||
DCD DMA_CH1_IRQHandler ; DMA channel 1 interrupt
|
||||
DCD DMA_CH2_IRQHandler ; DMA channel 2 interrupt
|
||||
DCD DMA_CH3_IRQHandler ; DMA channel 3 interrupt
|
||||
DCD DMA_CH4_IRQHandler ; DMA channel 4 interrupt
|
||||
DCD DMA_CH5_IRQHandler ; DMA channel 5 interrupt
|
||||
DCD DMA_CH6_IRQHandler ; DMA channel 6 interrupt
|
||||
DCD DMA_CH7_IRQHandler ; DMA channel 7 interrupt
|
||||
DCD DMA_CH8_IRQHandler ; DMA channel 8 interrupt
|
||||
DCD DMA_CH9_IRQHandler ; DMA channel 9 interrupt
|
||||
DCD DMA_CH10_IRQHandler ; DMA channel 10 interrupt
|
||||
DCD DMA_CH11_IRQHandler ; DMA channel 11 interrupt
|
||||
DCD DMA_CH12_IRQHandler ; DMA channel 12 interrupt
|
||||
DCD DMA_CH13_IRQHandler ; DMA channel 13 interrupt
|
||||
DCD DMA_CH14_IRQHandler ; DMA channel 14 interrupt
|
||||
DCD DMA_CH15_IRQHandler ; DMA channel 15 interrupt
|
||||
DCD TMR0_IRQHandler ; Timer 0 interrupt
|
||||
DCD TMR1_IRQHandler ; Timer 1 interrupt
|
||||
DCD TMR2_IRQHandler ; Timer 2 interrupt
|
||||
DCD TMR3_IRQHandler ; Timer 3 interrupt
|
||||
DCD UART0_TD_IRQHandler ; UART0 Transmit Done interrupt
|
||||
DCD UART0_RX_IRQHandler ; UART0 Recieve interrupt
|
||||
DCD UART0_TX_IRQHandler ; UART0 Transmit interrupt
|
||||
DCD UART0_E_RT_IRQHandler ; UART0 Error and Receive Timeout interrupt
|
||||
DCD UART1_TD_IRQHandler ; UART1 Transmit Done interrupt
|
||||
DCD UART1_RX_IRQHandler ; UART1 Recieve interrupt
|
||||
DCD UART1_TX_IRQHandler ; UART1 Transmit interrupt
|
||||
DCD UART1_E_RT_IRQHandler ; UART1 Error and Receive Timeout interrupt
|
||||
DCD SPI_RO_RT_IRQHandler ; SPI RX FIFO overrun and Receive Timeout interrupt
|
||||
DCD SPI_RX_IRQHandler ; SPI Receive interrupt
|
||||
DCD SPI_TX_IRQHandler ; SPI Transmit interrupt
|
||||
DCD I2C_IRQHandler ; I2C interrupt
|
||||
DCD ECAP0_IRQHandler ; ECAP0 interrupt
|
||||
DCD ECAP1_IRQHandler ; ECAP1 interrupt
|
||||
DCD ECAP2_IRQHandler ; ECAP2 interrupt
|
||||
DCD PWM0_IRQHandler ; PWM0 interrupt
|
||||
DCD PWM0_HD_IRQHandler ; PWM0 HD interrupt
|
||||
DCD PWM0_TZ_IRQHandler ; PWM0 TZ interrupt
|
||||
DCD PWM1_IRQHandler ; PWM1 interrupt
|
||||
DCD PWM1_HD_IRQHandler ; PWM1 HD interrupt
|
||||
DCD PWM1_TZ_IRQHandler ; PWM1 TZ interrupt
|
||||
DCD PWM2_IRQHandler ; PWM2 interrupt
|
||||
DCD PWM2_HD_IRQHandler ; PWM2 HD interrupt
|
||||
DCD PWM2_TZ_IRQHandler ; PWM2 TZ interrupt
|
||||
DCD QEP_IRQHandler ; QEP interrupt
|
||||
DCD ADC_SEQ0_IRQHandler ; ADC Sequencer 0 interrupt
|
||||
DCD ADC_SEQ1_IRQHandler ; ADC Sequencer 1 interrupt
|
||||
DCD ADC_DC_IRQHandler ; ADC Digital Comparator interrupt
|
||||
DCD CAN0_IRQHandler ; CAN0 interrupt
|
||||
DCD CAN1_IRQHandler ; CAN1 interrupt
|
||||
DCD CAN2_IRQHandler ; CAN2 interrupt
|
||||
DCD CAN3_IRQHandler ; CAN3 interrupt
|
||||
DCD CAN4_IRQHandler ; CAN4 interrupt
|
||||
DCD CAN5_IRQHandler ; CAN5 interrupt
|
||||
DCD CAN6_IRQHandler ; CAN6 interrupt
|
||||
DCD CAN7_IRQHandler ; CAN7 interrupt
|
||||
DCD CAN8_IRQHandler ; CAN8 interrupt
|
||||
DCD CAN9_IRQHandler ; CAN9 interrupt
|
||||
DCD CAN10_IRQHandler ; CAN10 interrupt
|
||||
DCD CAN11_IRQHandler ; CAN11 interrupt
|
||||
DCD CAN12_IRQHandler ; CAN12 interrupt
|
||||
DCD CAN13_IRQHandler ; CAN13 interrupt
|
||||
DCD CAN14_IRQHandler ; CAN14 interrupt
|
||||
DCD CAN15_IRQHandler ; CAN15 interrupt
|
||||
DCD FPU_IRQHandler ; FPU exception interrupt
|
||||
|
||||
__Vectors_End
|
||||
|
||||
__Vectors_Size EQU __Vectors_End - __Vectors
|
||||
|
||||
AREA |.text|, CODE, READONLY
|
||||
|
||||
; Reset handler
|
||||
Reset_Handler PROC
|
||||
EXPORT Reset_Handler [WEAK]
|
||||
IMPORT __main
|
||||
IMPORT SystemInit
|
||||
LDR R0, =SystemInit
|
||||
BLX R0
|
||||
LDR R0, =__main
|
||||
BX R0
|
||||
ENDP
|
||||
|
||||
; Dummy Exception Handlers (infinite loops which can be modified)
|
||||
|
||||
NMI_Handler PROC
|
||||
EXPORT NMI_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
HardFault_Handler\
|
||||
PROC
|
||||
EXPORT HardFault_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
MemManage_Handler\
|
||||
PROC
|
||||
EXPORT MemManage_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
BusFault_Handler\
|
||||
PROC
|
||||
EXPORT BusFault_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
UsageFault_Handler\
|
||||
PROC
|
||||
EXPORT UsageFault_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
SVC_Handler PROC
|
||||
EXPORT SVC_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
DebugMon_Handler\
|
||||
PROC
|
||||
EXPORT DebugMon_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
PendSV_Handler PROC
|
||||
EXPORT PendSV_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
SysTick_Handler PROC
|
||||
EXPORT SysTick_Handler [WEAK]
|
||||
B .
|
||||
ENDP
|
||||
|
||||
Default_Handler PROC
|
||||
|
||||
EXPORT WDT_IRQHandler [WEAK]
|
||||
EXPORT RCU_IRQHandler [WEAK]
|
||||
EXPORT MFLASH_IRQHandler [WEAK]
|
||||
EXPORT GPIOA_IRQHandler [WEAK]
|
||||
EXPORT GPIOB_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH0_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH1_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH2_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH3_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH4_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH5_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH6_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH7_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH8_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH9_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH10_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH11_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH12_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH13_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH14_IRQHandler [WEAK]
|
||||
EXPORT DMA_CH15_IRQHandler [WEAK]
|
||||
EXPORT TMR0_IRQHandler [WEAK]
|
||||
EXPORT TMR1_IRQHandler [WEAK]
|
||||
EXPORT TMR2_IRQHandler [WEAK]
|
||||
EXPORT TMR3_IRQHandler [WEAK]
|
||||
EXPORT UART0_TD_IRQHandler [WEAK]
|
||||
EXPORT UART0_RX_IRQHandler [WEAK]
|
||||
EXPORT UART0_TX_IRQHandler [WEAK]
|
||||
EXPORT UART0_E_RT_IRQHandler [WEAK]
|
||||
EXPORT UART1_TD_IRQHandler [WEAK]
|
||||
EXPORT UART1_RX_IRQHandler [WEAK]
|
||||
EXPORT UART1_TX_IRQHandler [WEAK]
|
||||
EXPORT UART1_E_RT_IRQHandler [WEAK]
|
||||
EXPORT SPI_RO_RT_IRQHandler [WEAK]
|
||||
EXPORT SPI_RX_IRQHandler [WEAK]
|
||||
EXPORT SPI_TX_IRQHandler [WEAK]
|
||||
EXPORT I2C_IRQHandler [WEAK]
|
||||
EXPORT ECAP0_IRQHandler [WEAK]
|
||||
EXPORT ECAP1_IRQHandler [WEAK]
|
||||
EXPORT ECAP2_IRQHandler [WEAK]
|
||||
EXPORT PWM0_IRQHandler [WEAK]
|
||||
EXPORT PWM0_HD_IRQHandler [WEAK]
|
||||
EXPORT PWM0_TZ_IRQHandler [WEAK]
|
||||
EXPORT PWM1_IRQHandler [WEAK]
|
||||
EXPORT PWM1_HD_IRQHandler [WEAK]
|
||||
EXPORT PWM1_TZ_IRQHandler [WEAK]
|
||||
EXPORT PWM2_IRQHandler [WEAK]
|
||||
EXPORT PWM2_HD_IRQHandler [WEAK]
|
||||
EXPORT PWM2_TZ_IRQHandler [WEAK]
|
||||
EXPORT QEP_IRQHandler [WEAK]
|
||||
EXPORT ADC_SEQ0_IRQHandler [WEAK]
|
||||
EXPORT ADC_SEQ1_IRQHandler [WEAK]
|
||||
EXPORT ADC_DC_IRQHandler [WEAK]
|
||||
EXPORT CAN0_IRQHandler [WEAK]
|
||||
EXPORT CAN1_IRQHandler [WEAK]
|
||||
EXPORT CAN2_IRQHandler [WEAK]
|
||||
EXPORT CAN3_IRQHandler [WEAK]
|
||||
EXPORT CAN4_IRQHandler [WEAK]
|
||||
EXPORT CAN5_IRQHandler [WEAK]
|
||||
EXPORT CAN6_IRQHandler [WEAK]
|
||||
EXPORT CAN7_IRQHandler [WEAK]
|
||||
EXPORT CAN8_IRQHandler [WEAK]
|
||||
EXPORT CAN9_IRQHandler [WEAK]
|
||||
EXPORT CAN10_IRQHandler [WEAK]
|
||||
EXPORT CAN11_IRQHandler [WEAK]
|
||||
EXPORT CAN12_IRQHandler [WEAK]
|
||||
EXPORT CAN13_IRQHandler [WEAK]
|
||||
EXPORT CAN14_IRQHandler [WEAK]
|
||||
EXPORT CAN15_IRQHandler [WEAK]
|
||||
EXPORT FPU_IRQHandler [WEAK]
|
||||
|
||||
|
||||
|
||||
WDT_IRQHandler
|
||||
RCU_IRQHandler
|
||||
MFLASH_IRQHandler
|
||||
GPIOA_IRQHandler
|
||||
GPIOB_IRQHandler
|
||||
DMA_CH0_IRQHandler
|
||||
DMA_CH1_IRQHandler
|
||||
DMA_CH2_IRQHandler
|
||||
DMA_CH3_IRQHandler
|
||||
DMA_CH4_IRQHandler
|
||||
DMA_CH5_IRQHandler
|
||||
DMA_CH6_IRQHandler
|
||||
DMA_CH7_IRQHandler
|
||||
DMA_CH8_IRQHandler
|
||||
DMA_CH9_IRQHandler
|
||||
DMA_CH10_IRQHandler
|
||||
DMA_CH11_IRQHandler
|
||||
DMA_CH12_IRQHandler
|
||||
DMA_CH13_IRQHandler
|
||||
DMA_CH14_IRQHandler
|
||||
DMA_CH15_IRQHandler
|
||||
TMR0_IRQHandler
|
||||
TMR1_IRQHandler
|
||||
TMR2_IRQHandler
|
||||
TMR3_IRQHandler
|
||||
UART0_TD_IRQHandler
|
||||
UART0_RX_IRQHandler
|
||||
UART0_TX_IRQHandler
|
||||
UART0_E_RT_IRQHandler
|
||||
UART1_TD_IRQHandler
|
||||
UART1_RX_IRQHandler
|
||||
UART1_TX_IRQHandler
|
||||
UART1_E_RT_IRQHandler
|
||||
SPI_RO_RT_IRQHandler
|
||||
SPI_RX_IRQHandler
|
||||
SPI_TX_IRQHandler
|
||||
I2C_IRQHandler
|
||||
ECAP0_IRQHandler
|
||||
ECAP1_IRQHandler
|
||||
ECAP2_IRQHandler
|
||||
PWM0_IRQHandler
|
||||
PWM0_HD_IRQHandler
|
||||
PWM0_TZ_IRQHandler
|
||||
PWM1_IRQHandler
|
||||
PWM1_HD_IRQHandler
|
||||
PWM1_TZ_IRQHandler
|
||||
PWM2_IRQHandler
|
||||
PWM2_HD_IRQHandler
|
||||
PWM2_TZ_IRQHandler
|
||||
QEP_IRQHandler
|
||||
ADC_SEQ0_IRQHandler
|
||||
ADC_SEQ1_IRQHandler
|
||||
ADC_DC_IRQHandler
|
||||
CAN0_IRQHandler
|
||||
CAN1_IRQHandler
|
||||
CAN2_IRQHandler
|
||||
CAN3_IRQHandler
|
||||
CAN4_IRQHandler
|
||||
CAN5_IRQHandler
|
||||
CAN6_IRQHandler
|
||||
CAN7_IRQHandler
|
||||
CAN8_IRQHandler
|
||||
CAN9_IRQHandler
|
||||
CAN10_IRQHandler
|
||||
CAN11_IRQHandler
|
||||
CAN12_IRQHandler
|
||||
CAN13_IRQHandler
|
||||
CAN14_IRQHandler
|
||||
CAN15_IRQHandler
|
||||
FPU_IRQHandler
|
||||
|
||||
|
||||
|
||||
B .
|
||||
|
||||
ENDP
|
||||
|
||||
ALIGN
|
||||
|
||||
;*******************************************************************************
|
||||
; User Stack and Heap initialization
|
||||
;*******************************************************************************
|
||||
IF :DEF:__MICROLIB
|
||||
|
||||
EXPORT __initial_sp
|
||||
EXPORT __heap_base
|
||||
EXPORT __heap_limit
|
||||
|
||||
ELSE
|
||||
|
||||
IMPORT __use_two_region_memory
|
||||
EXPORT __user_initial_stackheap
|
||||
|
||||
__user_initial_stackheap
|
||||
|
||||
LDR R0, = Heap_Mem
|
||||
LDR R1, =(Stack_Mem + Stack_Size)
|
||||
LDR R2, = (Heap_Mem + Heap_Size)
|
||||
LDR R3, = Stack_Mem
|
||||
BX LR
|
||||
|
||||
ALIGN
|
||||
|
||||
ENDIF
|
||||
|
||||
END
|
||||
|
||||
;******************* (C) COPYRIGHT 2018 NIIET *****END OF FILE*****
|
||||
@@ -0,0 +1,166 @@
|
||||
/*==============================================================================
|
||||
* Инициализация К1921ВК035
|
||||
*------------------------------------------------------------------------------
|
||||
* НИИЭТ, Богдан Колбов <kolbov@niiet.ru>
|
||||
*==============================================================================
|
||||
* ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ», БЕЗ КАКИХ-ЛИБО
|
||||
* ГАРАНТИЙ, ЯВНО ВЫРАЖЕННЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ ГАРАНТИИ ТОВАРНОЙ
|
||||
* ПРИГОДНОСТИ, СООТВЕТСТВИЯ ПО ЕГО КОНКРЕТНОМУ НАЗНАЧЕНИЮ И ОТСУТСТВИЯ
|
||||
* НАРУШЕНИЙ, НО НЕ ОГРАНИЧИВАЯСЬ ИМИ. ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ
|
||||
* ПРЕДНАЗНАЧЕНО ДЛЯ ОЗНАКОМИТЕЛЬНЫХ ЦЕЛЕЙ И НАПРАВЛЕНО ТОЛЬКО НА
|
||||
* ПРЕДОСТАВЛЕНИЕ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ О ПРОДУКТЕ, С ЦЕЛЬЮ СОХРАНИТЬ ВРЕМЯ
|
||||
* ПОТРЕБИТЕЛЮ. НИ В КАКОМ СЛУЧАЕ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ НЕ НЕСУТ
|
||||
* ОТВЕТСТВЕННОСТИ ПО КАКИМ-ЛИБО ИСКАМ, ЗА ПРЯМОЙ ИЛИ КОСВЕННЫЙ УЩЕРБ, ИЛИ
|
||||
* ПО ИНЫМ ТРЕБОВАНИЯМ, ВОЗНИКШИМ ИЗ-ЗА ИСПОЛЬЗОВАНИЯ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ
|
||||
* ИЛИ ИНЫХ ДЕЙСТВИЙ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
|
||||
*
|
||||
* 2018 АО "НИИЭТ"
|
||||
*==============================================================================
|
||||
*/
|
||||
|
||||
//-- Includes ------------------------------------------------------------------
|
||||
#include "system_K1921VK035.h"
|
||||
#include "K1921VK035.h"
|
||||
|
||||
//-- Variables -----------------------------------------------------------------
|
||||
uint32_t SystemCoreClock; // System Clock Frequency (Core Clock)
|
||||
|
||||
//-- Functions -----------------------------------------------------------------
|
||||
void SystemCoreClockUpdate(void)
|
||||
{
|
||||
uint32_t current_sysclk;
|
||||
uint32_t pll_n, pll_m, pll_od, pll_refclk, pll_div = 1;
|
||||
|
||||
current_sysclk = RCU->SYSCLKSTAT_bit.SYSSTAT;
|
||||
|
||||
switch (current_sysclk) {
|
||||
case RCU_SYSCLKSTAT_SYSSTAT_OSICLK:
|
||||
SystemCoreClock = OSICLK_VAL;
|
||||
break;
|
||||
case RCU_SYSCLKSTAT_SYSSTAT_OSECLK:
|
||||
SystemCoreClock = OSECLK_VAL;
|
||||
break;
|
||||
case RCU_SYSCLKSTAT_SYSSTAT_PLLDIVCLK:
|
||||
case RCU_SYSCLKSTAT_SYSSTAT_PLLCLK:
|
||||
if (current_sysclk == RCU_SYSCLKSTAT_SYSSTAT_PLLDIVCLK)
|
||||
pll_div = RCU->PLLDIV_bit.DIV + 1;
|
||||
pll_n = RCU->PLLCFG_bit.N;
|
||||
pll_m = RCU->PLLCFG_bit.M;
|
||||
pll_od = RCU->PLLCFG_bit.OD;
|
||||
if (RCU->PLLCFG_bit.REFSRC == RCU_PLLCFG_REFSRC_OSICLK)
|
||||
pll_refclk = OSICLK_VAL;
|
||||
else // RCU->PLLCFG_bit.REFSRC == RCU_PLLCFG_REFSRC_OSECLK
|
||||
pll_refclk = OSECLK_VAL;
|
||||
SystemCoreClock = (pll_refclk * pll_m) / (pll_n * (1 << pll_od) * pll_div);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void ClkInit()
|
||||
{
|
||||
uint32_t timeout_counter = 0;
|
||||
uint32_t sysclk_source;
|
||||
|
||||
//clockout control
|
||||
#if defined CKO_OSI
|
||||
SIU->CLKOUTCTL = SIU_CLKOUTCTL_CLKOUTEN_Msk;
|
||||
RCU->CLKOUTCFG = (RCU_CLKOUTCFG_CLKSEL_OSICLK << RCU_CLKOUTCFG_CLKSEL_Pos) |
|
||||
(RCU_CLKOUTCFG_CLKEN_Msk); //CKO = OSICLK
|
||||
#elif defined CKO_OSE && (OSECLK_VAL != 0)
|
||||
SIU->CLKOUTCTL = SIU_CLKOUTCTL_CLKOUTEN_Msk;
|
||||
RCU->CLKOUTCFG = (RCU_CLKOUTCFG_CLKSEL_OSECLK << RCU_CLKOUTCFG_CLKSEL_Pos) |
|
||||
(RCU_CLKOUTCFG_CLKEN_Msk); //CKO = OSECLK
|
||||
#elif defined CKO_PLL
|
||||
SIU->CLKOUTCTL = SIU_CLKOUTCTL_CLKOUTEN_Msk;
|
||||
RCU->CLKOUTCFG = (RCU_CLKOUTCFG_CLKSEL_PLLCLK << RCU_CLKOUTCFG_CLKSEL_Pos) |
|
||||
(1 << RCU_CLKOUTCFG_DIVN_Pos) |
|
||||
(RCU_CLKOUTCFG_DIVEN_Msk) |
|
||||
(RCU_CLKOUTCFG_CLKEN_Msk); //CKO = PLLCLK/4
|
||||
#endif
|
||||
|
||||
//wait till external oscillator is ready
|
||||
#if defined OSECLK_VAL && (OSECLK_VAL != 0)
|
||||
while ((!RCU->SYSCLKSTAT_bit.OSECLKOK) && (timeout_counter < OSECLK_STARTUP_TIMEOUT))
|
||||
timeout_counter++;
|
||||
if (timeout_counter == OSECLK_STARTUP_TIMEOUT) //OSE failed to startup
|
||||
while (1) {
|
||||
};
|
||||
#endif
|
||||
|
||||
//select system clock
|
||||
#ifdef SYSCLK_PLL
|
||||
//PLLCLK = REFSRC * (M/N) * (1/(2^OD))
|
||||
#if (OSECLK_VAL == 8000000)
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSECLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(1 << RCU_PLLCFG_N_Pos) |
|
||||
(25 << RCU_PLLCFG_M_Pos);
|
||||
#elif (OSECLK_VAL == 12000000)
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSECLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(3 << RCU_PLLCFG_N_Pos) |
|
||||
(50 << RCU_PLLCFG_M_Pos);
|
||||
#elif (OSECLK_VAL == 16000000)
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSECLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(2 << RCU_PLLCFG_N_Pos) |
|
||||
(25 << RCU_PLLCFG_M_Pos);
|
||||
#elif (OSECLK_VAL == 20000000)
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSECLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(2 << RCU_PLLCFG_N_Pos) |
|
||||
(20 << RCU_PLLCFG_M_Pos);
|
||||
#elif (OSECLK_VAL == 24000000)
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSECLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(3 << RCU_PLLCFG_N_Pos) |
|
||||
(25 << RCU_PLLCFG_M_Pos);
|
||||
#elif defined OSICLK_VAL
|
||||
RCU->PLLCFG = (RCU_PLLCFG_REFSRC_OSICLK << RCU_PLLCFG_REFSRC_Pos) |
|
||||
(1 << RCU_PLLCFG_N_Pos) |
|
||||
(25 << RCU_PLLCFG_M_Pos);
|
||||
#else
|
||||
#error "Please define OSICLK_VAL and OSECLK_VAL with correct values!"
|
||||
#endif
|
||||
RCU->PLLCFG |= (1 << RCU_PLLCFG_OD_Pos) |
|
||||
(RCU_PLLCFG_OUTEN_Msk);
|
||||
while (!RCU->PLLCFG_bit.LOCK) {
|
||||
};
|
||||
// additional waitstates
|
||||
MFLASH->CTRL = (3 << MFLASH_CTRL_LAT_Pos);
|
||||
//select PLL as source system clock
|
||||
sysclk_source = RCU_SYSCLKCFG_SYSSEL_PLLCLK;
|
||||
#elif defined SYSCLK_OSI
|
||||
sysclk_source = RCU_SYSCLKCFG_SYSSEL_OSICLK;
|
||||
#elif defined SYSCLK_OSE
|
||||
sysclk_source = RCU_SYSCLKCFG_SYSSEL_OSECLK;
|
||||
#else
|
||||
#error "Please define SYSCLK source (SYSCLK_PLL | SYSCLK_OSI | SYSCLK_OSE)!"
|
||||
#endif
|
||||
|
||||
//switch sysclk
|
||||
RCU->SYSCLKCFG = (sysclk_source << RCU_SYSCLKCFG_SYSSEL_Pos);
|
||||
// Wait switching done
|
||||
timeout_counter = 0;
|
||||
while ((RCU->SYSCLKSTAT_bit.SYSSTAT != RCU->SYSCLKCFG_bit.SYSSEL) && (timeout_counter < SYSCLK_SWITCH_TIMEOUT))
|
||||
timeout_counter++;
|
||||
if (timeout_counter == SYSCLK_SWITCH_TIMEOUT) //SYSCLK failed to switch
|
||||
while (1) {
|
||||
};
|
||||
|
||||
//flush and enable cache
|
||||
MFLASH->CTRL_bit.IFLUSH = 1;
|
||||
while (MFLASH->ICSTAT_bit.BUSY) {
|
||||
};
|
||||
MFLASH->CTRL_bit.DFLUSH = 1;
|
||||
while (MFLASH->DCSTAT_bit.BUSY) {
|
||||
};
|
||||
MFLASH->CTRL |= (MFLASH_CTRL_DCEN_Msk) | (MFLASH_CTRL_ICEN_Msk) | (MFLASH_CTRL_PEN_Msk);
|
||||
}
|
||||
|
||||
void FPUInit()
|
||||
{
|
||||
SCB->CPACR = 0x00F00000;
|
||||
__DSB();
|
||||
__ISB();
|
||||
}
|
||||
void SystemInit(void)
|
||||
{
|
||||
ClkInit();
|
||||
FPUInit();
|
||||
}
|
||||
BIN
MDK-ARM/platform/Device/NIIET/K1921VK035/РП_1921ВК035_201219.pdf
Normal file
BIN
MDK-ARM/platform/Device/NIIET/K1921VK035/РП_1921ВК035_201219.pdf
Normal file
Binary file not shown.
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****/
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user