Templates/VK035_Template
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Добавлен ADC SEQ (заготовка пока)

Browse Source 
И небольшой рефакторинг
This commit is contained in:
Razvalyaev
2025-12-26 18:44:38 +03:00
parent 8e350e6a91
commit c7fdf6776f
16 changed files with 1758 additions and 1933 deletions
Download Patch File Download Diff File Expand all files Collapse all files

437
Core/App/adc.c Normal file
View File

@@ -0,0 +1,437 @@
/*==============================================================================
* Инициализация АЦП с использованием бибилотеки PLIB035
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
* ЦНИИ СЭТ
*==============================================================================
*/
//-- Includes ------------------------------------------------------------------
#include "periph_config.h"
ADC_HandleTypeDef hadc;
//-- Defines -------------------------------------------------------------------
//-- Peripheral init functions -------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////SEQUENCORS/////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
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);
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_Config[ADC_SEQ_Num_1]->IT == ENABLE)
{
NVIC_EnableIRQ(ADC_SEQ1_IRQn);
}
#endif
#if (USE_ADC_DC0==1)
#endif
#if (USE_ADC_DC1==1)
#endif
#if (USE_ADC_DC2==1)
#endif
#if (USE_ADC_DC3==1)
#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 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_Init(SEQ_Num, &hseq->Config->SEQ_Init);
return OK;
}
/**
* @brief Установка коллбека секвенсора АЦП
* @param hadc указатель на хендл АЦП
* @param cb_type Тип коллбека
* @param Callback Функция коллбека
* @retval void
*/
OperationStatus adc_seq_set_callback(ADC_HandleTypeDef* hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_CallbackTypeDef cb_type, void (*Callback)(void))
{
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
return ERROR;
ADC_SEQ_HandleTypeDef *hseq = &hadc->SEQ[SEQ_Num];
switch(cb_type)
{
case ADC_Callback_Seq:
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; // Сбрасываем счетчик
// Настраиваем прерывания если нужно
if (conf->IT == ENABLE)
{
ADC_SEQ_ITConfig(SEQ_Num, conf->ITCount, DISABLE);
ADC_SEQ_ITCmd(SEQ_Num, ENABLE);
}
// Включаем секвенсор
ADC_SEQ_Cmd(SEQ_Num, ENABLE);
// Помечаем как запущенный
hseq->running = 1;
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);
// Сбрасываем флаг запуска
hseq->running = 1;
return OK;
}
/**
* @brief Получение текущего значения канала
* @param hadc указатель на хендл АЦП
* @param channel номер канала
* @retval значение ADC (0 если данные невалидны)
*/
uint16_t adc_get_channel_value(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel)
{
if (!hadc || channel >= ADC_CH_Total)
return 0;
if (hadc->ChannelValid[channel])
{
return hadc->ChannelData[channel];
}
return 0;
}
/**
* @brief Программный запуск преобразования
*/
void adc_sw_start(void)
{
ADC_SEQ_SwStartCmd();
}
/**
* @brief Обработчик прерываний секвенсора
* @param hadc указатель на хендл АЦП
* @param SEQ_Num номер секвенсора
* @retval void
*/
void adc_seq_handler(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num)
{
if (!hadc || !hadc->Instance || !hadc->SEQ[SEQ_Num].Config)
return;
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_ReqNum_TypeDef last_request = conf->SEQ_Init.ReqMax;
// Читаем все доступные данные из FIFO
uint8_t channels_processed = 0;
while (ADC_SEQ_GetFIFOLoad(ADC_SEQ_Num_0))
{
uint32_t data = ADC_SEQ_GetFIFOData(SEQ_Num);
ADC_SEQ_ReqNum_TypeDef req_num = ADC_SEQ_GetReqCurrent(SEQ_Num);
if (req_num < ADC_SEQ_Req_Total)
{
ADC_CH_Num_TypeDef channel = conf->SEQ_Init.Req[req_num];
if (channel < ADC_CH_Total)
{
// 1. Обновляем текущее значение
hadc->ChannelData[channel] = (uint16_t)data;
hadc->ChannelValid[channel] = 1;
// 2. Записываем в буфер если он есть
if (hseq->data_buffer &&
hseq->buffer_size > 0)
{
// Вычисляем offset для [ch][buffer_size]
uint32_t offset = channel * hseq->buffer_size +
hseq->buffer_count;
hseq->data_buffer[offset] = (uint16_t)data;
}
channels_processed++;
// Если это последний канал в секвенсоре - увеличиваем счетчик буфера
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->buffer_circular)
hseq->buffer_count = 0;
else
adc_seq_stop(hadc, SEQ_Num);
if (conf->BuffFullCallback)
{
conf->BuffFullCallback();
}
}
}
}
}
}
// Вызываем коллбек пользователя
if (conf->SEQCpltCallback)
{
conf->SEQCpltCallback();
}
}
// Обработка ошибок
if (ADC_SEQ_DMAErrorStatus(SEQ_Num) == SET)
{
ADC_SEQ_DMAErrorStatusClear(SEQ_Num);
if (conf->ErrorCallback)
{
conf->ErrorCallback();
}
}
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////DIGITAL COMPARATORS/////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///**
// * @brief Инициализация цифрового компаратора АЦП
// * @param hadc указатель на хендл АЦП
// * @param DC_Num номер компаратора
// * @param NewConfig указатель на конфигурацию
// * @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
// */
//OperationStatus adc_dc_init(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num, ADC_DC_ExtInit_TypeDef *NewConfig)
//{
// if(!hadc || !hadc->Instance)
// return ERROR;
//
// if(NewConfig != NULL)
// {
// hadc->DC_Config[DC_Num] = NewConfig;
// }
//
// if(hadc->DC_Config[DC_Num] == NULL)
// {
// return ERROR;
// }
//
// // Инициализация компаратора
// ADC_DC_Init(DC_Num, &hadc->DC_Config[DC_Num]->DC_Init);
//
// return OK;
//}
///**
// * @brief Установка коллбека цифрового компаратора АЦП
// * @param hadc указатель на хендл АЦП
// * @param DC_Num номер компаратора
// * @param cb_type тип коллбека
// * @param Callback функция коллбека
// * @retval OperationStatus
// */
//OperationStatus adc_dc_set_callback(ADC_HandleTypeDef* hadc, ADC_DC_Num_TypeDef DC_Num, ADC_CallbackTypeDef cb_type, void (*Callback)(void))
//{
// if (!hadc || !hadc->Instance || !hadc->DC_Config[DC_Num])
// return ERROR;
//
// switch(cb_type)
// {
// case ADC_Callback_DC:
// hadc->DC_Config[DC_Num]->DC_TrigCallback = Callback;
// break;
// case ADC_Callback_Error:
// hadc->DC_Config[DC_Num]->ErrorCallback = Callback;
// break;
// default:
// return ERROR;
// }
// return OK;
//}
///**
// * @brief Запуск цифрового компаратора АЦП
// * @param hadc указатель на хендл АЦП
// * @param DC_Num номер компаратора
// * @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
// */
//OperationStatus adc_dc_start(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num)
//{
// if (!hadc || !hadc->Instance || !hadc->DC_Config[DC_Num])
// return ERROR;
//
// ADC_DC_ExtInit_TypeDef *conf = hadc->DC_Config[DC_Num];
//
// // Включаем выход компаратора
// ADC_DC_OutputCmd(DC_Num, ENABLE);
//
// // Настраиваем прерывания если нужно
// if(conf->IT == ENABLE)
// {
// ADC_DC_ITCmd(DC_Num, ENABLE);
// }
//
// return OK;
//}
///**
// * @brief Остановка цифрового компаратора АЦП
// * @param hadc указатель на хендл АЦП
// * @param DC_Num номер компаратора
// * @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
// */
//OperationStatus adc_dc_stop(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num)
//{
// if (!hadc || !hadc->Instance || !hadc->DC_Config[DC_Num])
// return ERROR;
//
// // Выключаем выход компаратора
// ADC_DC_OutputCmd(DC_Num, DISABLE);
//
// // Выключаем прерывания
// ADC_DC_ITCmd(DC_Num, DISABLE);
//
// return OK;
//}
//void adc_dc_handler(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num)
//{
//}

99
Core/App/adc.h Normal file
View File

@@ -0,0 +1,99 @@
/*==============================================================================
* Инициализация таймеров с использованием бибилотеки PLIB035
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
* ЦНИИ СЭТ
*==============================================================================
*/
#ifndef __ADC_H
#define __ADC_H
//-- Includes ------------------------------------------------------------------
#include "plib035.h"
#include "retarget_conf.h"
//-- Defines -------------------------------------------------------------------
// Дефайны для режима АЦП
typedef enum
{
ADC_Callback_Seq,
ADC_Callback_BuffHalf,
ADC_Callback_BuffFull,
ADC_Callback_DC,
ADC_Callback_Error,
}ADC_CallbackTypeDef;
typedef struct
{
ADC_SEQ_Init_TypeDef SEQ_Init; /* Стандартная конфигурация из PLIB */
FunctionalState IT; /*!< Включить прерывания */
uint8_t ITCount; /*!< Количество запросов для генерации прерывания */
uint32_t buffer_circular; /*!< Циклический буфер */
void (*SEQCpltCallback)(void); /*!< Вызывается при завершении секвенсора */
void (*BuffHalfCallback)(void); /*!< Вызывается при заполнении половины буфера */
void (*BuffFullCallback)(void); /*!< Вызывается при заполнении буфера */
void (*ErrorCallback)(); /*!< Вызывается при ошибке */
}ADC_SEQ_ExtInit_TypeDef;
typedef struct
{
ADC_DC_Init_TypeDef DC_Init;
FunctionalState IT; /*!< Включить прерывания */
void (*DC_TrigCallback); /*!< Вызывается при срабатывании компаратора */
void (*ErrorCallback)(); /*!< Вызывается при ошибке */
}ADC_DC_ExtInit_TypeDef;
typedef struct
{
ADC_SEQ_ExtInit_TypeDef *Config; /*!< Конфигурации секвенсоров */
uint8_t running;
uint16_t *data_buffer; /*!< Указатель на буфер данных [ch][buffer_size]*/
uint32_t buffer_size; /*!< Размер буфера (16-bit слова) */
uint32_t buffer_count; /*!< Счетчик текущего индекса буфера */
}ADC_SEQ_HandleTypeDef;
typedef struct
{
ADC_DC_ExtInit_TypeDef *Config; /*!< Конфигурации компараторов */
uint8_t running;
}ADC_DC_HandleTypeDef;
typedef struct
{
ADC_TypeDef *Instance; /*!< Регистры ADC */
ADC_SEQ_HandleTypeDef SEQ[ADC_SEQ_Total]; /*!< Хендл секвенсоров */
ADC_DC_ExtInit_TypeDef DC[ADC_DC_Total]; /*!< Хендл компараторов */
// Буферы данных для каждого канала (актуальные значения)
uint16_t ChannelData[ADC_CH_Total]; /*!< Текущие значения каналов */
uint8_t ChannelValid[ADC_CH_Total]; /*!< Флаги валидности данных */
}ADC_HandleTypeDef;
extern ADC_HandleTypeDef hadc;
//-- Exported functions prototypes ---------------------------------------------
void adc_init_first(void);
OperationStatus adc_seq_init(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_SEQ_ExtInit_TypeDef *NewConfig);
OperationStatus adc_seq_set_callback(ADC_HandleTypeDef* hadc, ADC_SEQ_Num_TypeDef SEQ_Num, ADC_CallbackTypeDef cb_type, 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);
uint16_t adc_get_channel_value(ADC_HandleTypeDef *hadc, ADC_CH_Num_TypeDef channel);
void adc_sw_start(void);
// Обработчики прерываний
void adc_seq_handler(ADC_HandleTypeDef *hadc, ADC_SEQ_Num_TypeDef SEQ_Num);
void adc_dc_handler(ADC_HandleTypeDef *hadc, ADC_DC_Num_TypeDef DC_Num);
#endif /*__ADC_H*/

78
Core/App/gpio.h
View File

@@ -1,5 +1,5 @@
/*==============================================================================
* Конфигурация портов с использованием бибилотеки PLIB035
* Инициализация портов с использованием бибилотеки PLIB035
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
@@ -21,82 +21,6 @@
#define GPIO_PinMode_AltFunc DISABLE, ENABLE, ENABLE
//#define GPIO_PinMode_Analog DISABLE, DISABLE, DISABLE
// Другой вариант
//#define GPIO_OUT_PP_PA_PINS /* GPIO_Pin_0 | */ \
// /* GPIO_Pin_1 | */ \
// /* GPIO_Pin_2 | */ \
// /* GPIO_Pin_3 | */ \
// /* GPIO_Pin_4 | */ \
// /* GPIO_Pin_5 | */ \
// /* GPIO_Pin_6 | */ \
// GPIO_Pin_7 | \
// GPIO_Pin_8 | \
// /* GPIO_Pin_9 | */ \
// /* GPIO_Pin_10 | */ \
// /* GPIO_Pin_11 | */ \
// /* GPIO_Pin_12 | */ \
// /* GPIO_Pin_13 | */ \
// /* GPIO_Pin_14 | */ \
// /* GPIO_Pin_15 | */ \
// 0
//#define GPIO_OUT_PP_PB_PINS /* GPIO_Pin_0 | */ \
// /* GPIO_Pin_1 | */ \
// /* GPIO_Pin_2 | */ \
// /* GPIO_Pin_3 | */ \
// /* GPIO_Pin_4 | */ \
// /* GPIO_Pin_5 | */ \
// /* GPIO_Pin_6 | */ \
// /* GPIO_Pin_7 | */ \
// /* GPIO_Pin_8 | */ \
// /* GPIO_Pin_9 | */ \
// /* GPIO_Pin_10 | */ \
// /* GPIO_Pin_11 | */ \
// /* GPIO_Pin_12 | */ \
// /* GPIO_Pin_13 | */ \
// /* GPIO_Pin_14 | */ \
// /* GPIO_Pin_15 | */ \
// 0
//
//
//#define GPIO_OUT_OD_PA_PINS /* GPIO_Pin_0 | */ \
// /* GPIO_Pin_1 | */ \
// /* GPIO_Pin_2 | */ \
// /* GPIO_Pin_3 | */ \
// /* GPIO_Pin_4 | */ \
// /* GPIO_Pin_5 | */ \
// /* GPIO_Pin_6 | */ \
// /* GPIO_Pin_7 | */ \
// /* GPIO_Pin_8 | */ \
// /* GPIO_Pin_9 | */ \
// /* GPIO_Pin_10 | */ \
// /* GPIO_Pin_11 | */ \
// /* GPIO_Pin_12 | */ \
// /* GPIO_Pin_13 | */ \
// /* GPIO_Pin_14 | */ \
// /* GPIO_Pin_15 | */ \
// 0
//
//#define GPIO_OUT_OD_PB_PINS /* GPIO_Pin_0 | */ \
// /* GPIO_Pin_1 | */ \
// /* GPIO_Pin_2 | */ \
// /* GPIO_Pin_3 | */ \
// /* GPIO_Pin_4 | */ \
// /* GPIO_Pin_5 | */ \
// /* GPIO_Pin_6 | */ \
// /* GPIO_Pin_7 | */ \
// /* GPIO_Pin_8 | */ \
// /* GPIO_Pin_9 | */ \
// /* GPIO_Pin_10 | */ \
// /* GPIO_Pin_11 | */ \
// /* GPIO_Pin_12 | */ \
// /* GPIO_Pin_13 | */ \
// /* GPIO_Pin_14 | */ \
// /* GPIO_Pin_15 | */ \
// 0
//-- Exported functions prototypes ---------------------------------------------
void gpio_init(void);
GPIO_Init_TypeDef *gpio_get_init(GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin);

5
Core/App/main.c
View File

@@ -3,7 +3,6 @@
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
* Конфигурация портов настраивается в gpio.h
* ЦНИИ СЭТ
*==============================================================================
*/
@@ -15,11 +14,13 @@ void restart_receive(void);
void heartbit(void);
//-- Defines -------------------------------------------------------------------
uint8_t rxbuff[10] = {0};
uint16_t adc_buff[2][100];
//-- Peripheral init functions -------------------------------------------------
void periph_init()
{
sysclk_init();
uart_init_first();
adc_init_first();
tmr_init_first();
gpio_init();
#ifdef RETARGET
@@ -35,6 +36,7 @@ void periph_init()
tmr_start(&htmr0);
tmr_start(&htmr1);
tmr_start(&htmr2);
adc_seq_start(&hadc, ADC_SEQ_Num_0, adc_buff, 100);
}
//-- Main ----------------------------------------------------------------------
@@ -50,6 +52,7 @@ int main()
{
tmr_delay_start(&htmr0, &prev_tick);
GPIO_ToggleBits(GPIOA, GPIO_Pin_8);
adc_sw_start();
}
tmr_delay(&htmr0, 100000);
GPIO_ToggleBits(GPIOA, GPIO_Pin_7);

1
Core/App/main.h
View File

@@ -3,7 +3,6 @@
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
* Конфигурация портов настраивается в gpio.h
* ЦНИИ СЭТ
*==============================================================================
*/

33
Core/App/sysclk.c
View File

@@ -48,3 +48,36 @@ void micros_inc(void)
{
uwTick++;
}
OperationStatus rcu_set_clock_adc(RCU_PeriphClk_TypeDef ClkSrc, float ClkMHz, FunctionalState state)
{
RCU_ADCClkCmd(DISABLE);
uint32_t adc_raw_clock = 0;
float adc_clock_div = 0;
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;
}
adc_clock_div = adc_raw_clock/(ClkMHz*__MHZ);
if(adc_clock_div < 1)
return ERROR;
RCU_ADCClkConfig(ClkSrc, 7, ENABLE); //12.5MHz
RCU_ADCClkCmd(ENABLE);
return OK;
}

4
Core/App/sysclk.h
View File

@@ -23,4 +23,8 @@ uint32_t millis(void);
void millis_inc(void);
uint32_t micros(void);
void micros_inc(void);
OperationStatus rcu_set_clock_adc(RCU_PeriphClk_TypeDef ClkSrc, float ClkMHz, FunctionalState state);
#endif /*__RCU_H*/

55
Core/App/tmr.c
View File

@@ -23,7 +23,7 @@ void tmr_init_first(void)
RCU_APBClkCmd(RCU_APBClk_TMR0, ENABLE);
RCU_APBRstCmd(RCU_APBRst_TMR0, ENABLE);
htmr0.TMR = TMR0;
htmr0.Instance = TMR0;
tmr_init(&htmr0, &tmr0_config);
if(htmr0.Config->IT == ENABLE)
{
@@ -35,7 +35,7 @@ void tmr_init_first(void)
RCU_APBClkCmd(RCU_APBClk_TMR1, ENABLE);
RCU_APBRstCmd(RCU_APBRst_TMR1, ENABLE);
htmr1.TMR = TMR1;
htmr1.Instance = TMR1;
tmr_init(&htmr1, &tmr1_config);
if(htmr1.Config->IT == ENABLE)
{
@@ -47,7 +47,7 @@ void tmr_init_first(void)
RCU_APBClkCmd(RCU_APBClk_TMR2, ENABLE);
RCU_APBRstCmd(RCU_APBRst_TMR2, ENABLE);
htmr2.TMR = TMR2;
htmr2.Instance = TMR2;
tmr_init(&htmr2, &tmr2_config);
if(htmr2.Config->IT == ENABLE)
{
@@ -59,7 +59,7 @@ void tmr_init_first(void)
RCU_APBClkCmd(RCU_APBClk_TMR3, ENABLE);
RCU_APBRstCmd(RCU_APBRst_TMR3, ENABLE);
htmr3.TMR = TMR3;
htmr3.Instance = TMR3;
tmr_init(&htmr3, &tmr3_config);
if(htmr3.Config->IT == ENABLE)
{
@@ -74,12 +74,11 @@ void tmr_init_first(void)
* @param NewConfig указатель на новую конфигурацию UART, иначе используется та, что в структуре
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
*/
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_Init_TypeDef *NewConfig)
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_ExtInit_TypeDef *NewConfig)
{
if(htmr->TMR == NULL)
{
if(!htmr || !htmr->Instance)
return ERROR;
}
if(NewConfig != NULL)
{
htmr->Config = NewConfig;
@@ -89,7 +88,7 @@ OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_Init_TypeDef *NewConfig)
return ERROR;
}
TMR_Init(htmr->TMR, htmr->Config);
TMR_Init(htmr->Instance, htmr->Config);
return OK;
}
@@ -104,7 +103,7 @@ OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_Init_TypeDef *NewConfig)
*/
OperationStatus tmr_set_callback(TMR_HandleTypeDef* htmr, int cb_type, void (*Callback)(void))
{
if((htmr->TMR == NULL) || (htmr->Config == NULL))
if(!htmr || !htmr->Instance || !htmr->Config)
{
return ERROR;
}
@@ -119,12 +118,12 @@ OperationStatus tmr_set_callback(TMR_HandleTypeDef* htmr, int cb_type, void (*Ca
*/
OperationStatus tmr_start(TMR_HandleTypeDef *htmr)
{
if(htmr->TMR == NULL)
if(!htmr || !htmr->Instance)
{
return ERROR;
}
TMR_Cmd(htmr->TMR, ENABLE);
TMR_Cmd(htmr->Instance, ENABLE);
return OK;
}
@@ -136,12 +135,12 @@ OperationStatus tmr_start(TMR_HandleTypeDef *htmr)
*/
OperationStatus tmr_stop(TMR_HandleTypeDef *htmr)
{
if(htmr->TMR == NULL)
if(!htmr || !htmr->Instance)
{
return ERROR;
}
TMR_Cmd(htmr->TMR, DISABLE);
TMR_Cmd(htmr->Instance, DISABLE);
return OK;
}
@@ -154,7 +153,7 @@ OperationStatus tmr_stop(TMR_HandleTypeDef *htmr)
*/
OperationStatus tmr_delay(TMR_HandleTypeDef *htmr, uint32_t delay)
{
if(!htmr || !htmr->TMR)
if(!htmr || !htmr->Instance)
return ERROR;
uint32_t presc = htmr->Config->Prescaler+1;
@@ -164,14 +163,14 @@ OperationStatus tmr_delay(TMR_HandleTypeDef *htmr, uint32_t delay)
delay_load = 0xFFFFFFFF;
}
if(delay_load >= htmr->TMR->LOAD)
if(delay_load >= htmr->Instance->LOAD)
{
return ERROR;
}
uint32_t starttick = htmr->TMR->VALUE;
uint32_t starttick = htmr->Instance->VALUE;
while(1)
{
if((starttick - htmr->TMR->VALUE) >= delay_load)
if((starttick - htmr->Instance->VALUE) >= delay_load)
{
return OK;
}
@@ -188,10 +187,10 @@ OperationStatus tmr_delay(TMR_HandleTypeDef *htmr, uint32_t delay)
*/
OperationStatus tmr_delay_start(TMR_HandleTypeDef *htmr, uint32_t *var)
{
if(!htmr || !htmr->TMR)
if(!htmr || !htmr->Instance)
return ERROR;
*var = htmr->TMR->VALUE;
*var = htmr->Instance->VALUE;
return OK;
}
@@ -207,7 +206,7 @@ OperationStatus tmr_delay_start(TMR_HandleTypeDef *htmr, uint32_t *var)
*/
int tmr_delay_done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var)
{
if(!htmr || !htmr->TMR)
if(!htmr || !htmr->Instance)
return 0;
uint32_t presc = htmr->Config->Prescaler+1;
@@ -217,12 +216,12 @@ int tmr_delay_done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var)
delay_load = 0xFFFFFFFF;
}
if(delay_load >= htmr->TMR->LOAD)
if(delay_load >= htmr->Instance->LOAD)
{
return 0;
}
if((*var - htmr->TMR->VALUE) >= delay_load)
if((*var - htmr->Instance->VALUE) >= delay_load)
{
return 1; // Задержка прошла
}
@@ -241,20 +240,20 @@ int tmr_delay_done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var)
*/
void tmr_handler(TMR_HandleTypeDef* htmr)
{
if((htmr->TMR == NULL) || (htmr->Config == NULL))
if((htmr->Instance == NULL) || (htmr->Config == NULL))
{
return;
}
/* Проверка флага прерывания таймера */
if (TMR_ITStatus(htmr->TMR) == SET)
if (TMR_ITStatus(htmr->Instance) == SET)
{
/* Если есть коллбек вызываем его */
if(htmr->Config->Callback)
htmr->Config->Callback();
/* Очистка флага прерывания */
TMR_ITStatusClear(htmr->TMR);
TMR_ITStatusClear(htmr->Instance);
}
}
@@ -263,11 +262,11 @@ void tmr_handler(TMR_HandleTypeDef* htmr)
/**
* @brief Инициализирует модуль TMRx согласно параметрам структуры InitStruct.
* @param TMRx Выбор таймера, где x=A|B
* @param InitStruct Указатель на структуру типа @ref TMR_Init_TypeDef,
* @param InitStruct Указатель на структуру типа @ref TMR_ExtInit_TypeDef,
* которая содержит конфигурационную информацию
* @retval void
*/
void TMR_Init(TMR_TypeDef* TMRx, TMR_Init_TypeDef* InitStruct)
void TMR_Init(TMR_TypeDef* TMRx, TMR_ExtInit_TypeDef* InitStruct)
{
uint32_t tim_clk = InitStruct->ClkFreq*__MHZ;
uint32_t presc = InitStruct->Prescaler+1;

10
Core/App/tmr.h
View File

@@ -32,12 +32,12 @@ typedef struct
FunctionalState DMAReq; /*!< Разрешение генерации запросов к DMA */
TMR_ExtInput_TypeDef ExtInput; /*!< Настройка внешнего тактирования таймера */
void (*Callback)(void); /* Коллбек который вызовется по прерыванию таймера */
}TMR_Init_TypeDef;
}TMR_ExtInit_TypeDef;
typedef struct
{
TMR_TypeDef *TMR;
TMR_Init_TypeDef *Config;
TMR_TypeDef *Instance;
TMR_ExtInit_TypeDef *Config;
}TMR_HandleTypeDef;
extern TMR_HandleTypeDef htmr0;
@@ -48,7 +48,7 @@ extern TMR_HandleTypeDef htmr3;
//-- Exported functions prototypes ---------------------------------------------
void tmr_init_first(void);
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_Init_TypeDef *NewConfig);
OperationStatus tmr_init(TMR_HandleTypeDef *htmr, TMR_ExtInit_TypeDef *NewConfig);
OperationStatus tmr_set_callback(TMR_HandleTypeDef* htmr, int cb_type, void (*Callback)(void));
OperationStatus tmr_start(TMR_HandleTypeDef *htmr);
@@ -59,5 +59,5 @@ int tmr_delay_done(TMR_HandleTypeDef *htmr, uint32_t delay, uint32_t *var);
void tmr_handler(TMR_HandleTypeDef* htmr);
void TMR_Init(TMR_TypeDef* TMRx, TMR_Init_TypeDef* InitStruct);
void TMR_Init(TMR_TypeDef* TMRx, TMR_ExtInit_TypeDef* InitStruct);
#endif /*__TMR_H*/

64
Core/App/uart.c
View File

@@ -1,5 +1,5 @@
/*==============================================================================
* Инициализация тактирования с использованием бибилотеки PLIB035
* Инициализация Instance с использованием бибилотеки PLIB035
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
@@ -35,7 +35,7 @@ void uart_init_first(void)
RCU_UARTClkCmd(UART0_Num, ENABLE);
UART_DeInit(UART0);
// Инициализируем UART0
huart0.UART = UART0;
huart0.Instance = UART0;
uart_init(&huart0, &uart0_config);
NVIC_EnableIRQ(UART0_TD_IRQn);
NVIC_EnableIRQ(UART0_RX_IRQn);
@@ -59,9 +59,8 @@ void uart_init_first(void)
NVIC_EnableIRQ(UART1_TX_IRQn);
NVIC_EnableIRQ(UART1_E_RT_IRQn);
huart1.UART = UART1;
uart_init(&huart1, &uart1_config);
huart1.Instance = UART1;
uart_init(&huart1, &uart1_config);
#endif
}
@@ -69,17 +68,16 @@ void uart_init_first(void)
/**
* @brief Инициализация UART
* @param htmr указатель на хендл UART
* @param NewConfig указатель на новую конфигурацию UART, иначе используется та, что в структуре
* @brief Инициализация Instance
* @param htmr указатель на хендл Instance
* @param NewConfig указатель на новую конфигурацию Instance, иначе используется та, что в структуре
* @retval OperationStatus OK - если всё хорошо, ERROR - если ошибка
*/
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInitTypeDef *NewConfig)
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInit_TypeDef *NewConfig)
{
if(huart->UART == NULL)
{
if(!huart || !huart->Instance)
return ERROR;
}
if(NewConfig != NULL)
{
huart->Config = NewConfig;
@@ -89,18 +87,18 @@ OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInitTypeDef *NewCon
return ERROR;
}
UART_Init(huart->UART, &huart->Config->UART_Init);
UART_Init(huart->Instance, &huart->Config->UART_Init);
return OK;
}
OperationStatus uart_start(UART_HandleTypeDef *huart, UART_FIFOLevel_TypeDef TxFifoLevel, UART_FIFOLevel_TypeDef RxFifoLevel)
{
if (huart == NULL)
if (!huart)
return ERROR;
UART_ITFIFOLevelRxConfig(huart->UART, RxFifoLevel);
UART_ITFIFOLevelTxConfig(huart->UART, TxFifoLevel);
UART_ITFIFOLevelRxConfig(huart->Instance, RxFifoLevel);
UART_ITFIFOLevelTxConfig(huart->Instance, TxFifoLevel);
huart->TxBufPtr = NULL;
@@ -113,7 +111,7 @@ OperationStatus uart_start(UART_HandleTypeDef *huart, UART_FIFOLevel_TypeDef TxF
huart->RxSize = 0;
huart->RxBusy = 0;
UART_Cmd(huart->UART, ENABLE);
UART_Cmd(huart->Instance, ENABLE);
return OK;
}
@@ -192,7 +190,7 @@ OperationStatus uart_transmit_it(UART_HandleTypeDef *huart,
huart->TxBusy = 1;
// Включаем прерывания по TX FIFO
UART_ITCmd(huart->UART, UART_ITSource_TxFIFOLevel, ENABLE);
UART_ITCmd(huart->Instance, UART_ITSource_TxFIFOLevel, ENABLE);
__uart_fifo_transmit(huart, 1);
@@ -218,7 +216,7 @@ OperationStatus uart_receive_it(UART_HandleTypeDef *huart,
huart->RxBusy = 1;
// Включаем только RX прерывания
UART_ITCmd(huart->UART,
UART_ITCmd(huart->Instance,
UART_ITSource_RxFIFOLevel |
UART_ITSource_RecieveTimeout |
UART_ITSource_ErrorFrame |
@@ -233,10 +231,10 @@ OperationStatus uart_receive_it(UART_HandleTypeDef *huart,
void uart_handler(UART_HandleTypeDef *huart)
{
if (!huart || !huart->UART || !huart->Config)
if (!huart || !huart->Instance || !huart->Config)
return;
UART_TypeDef *uart = huart->UART;
UART_TypeDef *uart = huart->Instance;
uint32_t mis = uart->MIS;
// Ошибки
@@ -304,18 +302,16 @@ void uart_handler(UART_HandleTypeDef *huart)
/**
* @brief Установка коллбека UART
* @param htmr указатель на хендл UART
* @brief Установка коллбека Instance
* @param htmr указатель на хендл Instance
* @param cb_type Тип коллбека
* @param Callback Функция коллбека
* @retval void
*/
OperationStatus uart_set_callback(UART_HandleTypeDef* huart, UART_CallbackTypeDef cb_type, void (*Callback)(void))
{
if((huart->UART == NULL) || (huart->Config == NULL))
{
if (!huart || !huart->Instance || !huart->Config)
return ERROR;
}
switch(cb_type)
{
@@ -449,10 +445,10 @@ void uart1_gpio_deinit(void)
static int __uart_fifo_receive(UART_HandleTypeDef *huart, uint8_t it_mode)
{
while (!UART_FlagStatus(huart->UART, UART_Flag_RxFIFOEmpty) &&
while (!UART_FlagStatus(huart->Instance, UART_Flag_RxFIFOEmpty) &&
huart->RxCount < huart->RxSize)
{
huart->RxBufPtr[huart->RxCount++] = UART_RecieveData(huart->UART);
huart->RxBufPtr[huart->RxCount++] = UART_RecieveData(huart->Instance);
if (huart->RxCount == huart->RxSize)
{
@@ -461,7 +457,7 @@ static int __uart_fifo_receive(UART_HandleTypeDef *huart, uint8_t it_mode)
if(it_mode)
{
// Выключаем RX прерывания
UART_ITCmd(huart->UART,
UART_ITCmd(huart->Instance,
UART_ITSource_RxFIFOLevel |
UART_ITSource_RecieveTimeout,
DISABLE);
@@ -476,10 +472,10 @@ static int __uart_fifo_receive(UART_HandleTypeDef *huart, uint8_t it_mode)
}
static int __uart_fifo_transmit(UART_HandleTypeDef *huart, uint8_t it_mode)
{
while (!UART_FlagStatus(huart->UART, UART_Flag_TxFIFOFull) &&
while (!UART_FlagStatus(huart->Instance, UART_Flag_TxFIFOFull) &&
huart->TxCount < huart->TxSize)
{
UART_SendData(huart->UART, huart->TxBufPtr[huart->TxCount++]);
UART_SendData(huart->Instance, huart->TxBufPtr[huart->TxCount++]);
}
if (huart->TxCount == huart->TxSize)
@@ -487,13 +483,13 @@ static int __uart_fifo_transmit(UART_HandleTypeDef *huart, uint8_t it_mode)
if(it_mode)
{
// Выключаем FIFO прерывание
UART_ITCmd(huart->UART, UART_ITSource_TxFIFOLevel, DISABLE);
UART_ITCmd(huart->Instance, UART_ITSource_TxFIFOLevel, DISABLE);
// Включаем TransmitDone прерывание, коллбек будет по нему
UART_ITCmd(huart->UART, UART_ITSource_TransmitDone, ENABLE);
UART_ITCmd(huart->Instance, UART_ITSource_TransmitDone, ENABLE);
}
else
{
while(!UART_FlagStatus(huart->UART, UART_Flag_TxFIFOEmpty)); // ждем пока не опустошится буфер
while(!UART_FlagStatus(huart->Instance, UART_Flag_TxFIFOEmpty)); // ждем пока не опустошится буфер
huart->TxBusy = 0;
if (huart->Config->TxCallback)

10
Core/App/uart.h
View File

@@ -1,5 +1,5 @@
/*==============================================================================
* Инициализация тактирования с использованием бибилотеки PLIB035
* Инициализация UART с использованием бибилотеки PLIB035
*------------------------------------------------------------------------------
* ЦНИИ СЭТ, Разваляев Алексей <wot890089@mail.ru>
*==============================================================================
@@ -56,15 +56,15 @@ typedef struct
void (*IdleCallback)(void); /* Вызывается при IDLE линии на RX */
void (*ErrCallback)(void); /* Вызывается при ошибке */
} UART_ExtInitTypeDef;
} UART_ExtInit_TypeDef;
typedef struct
{
UART_TypeDef *UART; /* Регистры UART */
UART_ExtInitTypeDef *Config; /* Конфигурация UART */
UART_TypeDef *Instance; /* Регистры UART */
UART_ExtInit_TypeDef *Config; /* Конфигурация UART */
/* ===== TX ===== */
const uint8_t *TxBufPtr; /* текущий массив для передачи*/
@@ -85,7 +85,7 @@ extern UART_HandleTypeDef huart1;
//-- Exported functions prototypes ---------------------------------------------
void uart_init_first(void);
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInitTypeDef *NewConfig);
OperationStatus uart_init(UART_HandleTypeDef *huart, UART_ExtInit_TypeDef *NewConfig);
OperationStatus uart_set_callback(UART_HandleTypeDef* huart, UART_CallbackTypeDef cb_type, void (*Callback)(void));
OperationStatus uart_start(UART_HandleTypeDef *huart, UART_FIFOLevel_TypeDef TxFifoLevel, UART_FIFOLevel_TypeDef RxFifoLevel);

25
Core/App/vk035_it.c
View File

@@ -12,21 +12,9 @@
/******************************************************************************/
/* STM32G4xx Peripheral Interrupt Handlers */
/* 1921VK035 Peripheral Interrupt Handlers */
/* Add here the Interrupt Handlers for the used peripherals. */
/* For the available peripheral interrupt handler names, */
/* please refer to the startup file (startup_stm32g4xx.s). */
/******************************************************************************/
void WDT_IRQHandler(void)
{
}
void RCU_IRQHandler(void)
{
}
void MFLASH_IRQHandler(void)
{
}
void GPIOA_IRQHandler(void)
{
}
@@ -134,9 +122,11 @@ void QEP_IRQHandler(void)
}
void ADC_SEQ0_IRQHandler(void)
{
adc_seq_handler(&hadc, ADC_SEQ_Num_0);
}
void ADC_SEQ1_IRQHandler(void)
{
adc_seq_handler(&hadc, ADC_SEQ_Num_1);
}
void ADC_DC_IRQHandler(void)
{
@@ -240,6 +230,15 @@ void DMA_CH14_IRQHandler(void)
void DMA_CH15_IRQHandler(void)
{
}
void WDT_IRQHandler(void)
{
}
void RCU_IRQHandler(void)
{
}
void MFLASH_IRQHandler(void)
{
}
/******************************************************************************/

172
Core/Config/periph_config.h
View File

@@ -12,8 +12,9 @@
//-- Includes ------------------------------------------------------------------
#include "sysclk.h"
#include "gpio.h"
#include "tmr.h"
#include "uart.h"
#include "tmr.h"
#include "adc.h"
void Error_Handler(void);
//-- Общие Конфигурации -------------------------------------------------------
@@ -26,6 +27,13 @@ void Error_Handler(void);
#define USE_TMR2 1
#define USE_TMR3 0
#define USE_ADC_SEQ0 1
#define USE_ADC_SEQ1 0
#define USE_ADC_DC0 0
#define USE_ADC_DC1 0
#define USE_ADC_DC2 0
#define USE_ADC_DC3 0
//#define RETARGET // закоментирован - отключен,
// // разкоментирован - включен
//#define RETARGET_USE_ITM // закоментирован - использовать UART,
@@ -33,7 +41,7 @@ void Error_Handler(void);
// Для дальнейшей настройки RETARGET -> retarget_conf.h
//-- RCU Конфигурации ---------------------------------------------------------
static RCU_PLL_Ref_TypeDef SYSCLK_Oscil_Type = RCU_PLL_Ref_OSIClk;
static RCU_PLL_Ref_TypeDef SYSCLK_Oscil_Type = RCU_PLL_Ref_OSEClk;
#define SYSCLK_CORE_CLOCK_MHZ 100
//-- GPIO Конфигурации --------------------------------------------------------
@@ -42,7 +50,7 @@ static RCU_PLL_Ref_TypeDef SYSCLK_Oscil_Type = RCU_PLL_Ref_OSIClk;
Периферия сама настроит нужные пины в gpiox_config на альтернативные функции
*/
static GPIO_Init_TypeDef gpioa_config[] = {
// Пин, Режим, Выходной режим, Входной режим, Подтяжка, Нагрузка/Скорость
// Пин, Режим, Выходной режим, Входной режим, Подтяжка, Нагрузка/Скорость
{ 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 },
@@ -62,7 +70,7 @@ static GPIO_Init_TypeDef gpioa_config[] = {
};
static GPIO_Init_TypeDef gpiob_config[] = {
// Пин, Режим, Выходной режим, Входной режим, Подтяжка, Нагрузка/Скорость
// Пин, Режим, Выходной режим, Входной режим, Подтяжка, Нагрузка/Скорость
{ 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 },
@@ -82,52 +90,158 @@ static GPIO_Init_TypeDef gpiob_config[] = {
};
//-- UART Конфигурации --------------------------------------------------------
#if USE_UART0==1
static UART_ExtInit_TypeDef uart0_config = {
//Стоп биты, Четность, Длина посылки, Скорость, FIFO, Направление работы
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx,
//Rx Коллбек Tx Коллбек Idle Коллбек Error Коллбек
NULL, NULL, NULL, NULL
};
#endif
#if USE_UART1==1
static UART_ExtInit_TypeDef uart1_config = {
//Стоп биты, Четность, Длина посылки, Скорость, FIFO, Направление работы
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx,
//Rx Коллбек Tx Коллбек Idle Коллбек Error Коллбек
NULL, NULL, NULL, NULL
};
#endif
//-- TMR Конфигурации ---------------------------------------------------------
#if USE_TMR0==1
static TMR_Init_TypeDef tmr0_config = {
// Частота Clk МГц, Период обновления Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование Коллбек
SYSCLK_CORE_CLOCK_MHZ, LOAD(0xFFFFFFFF, SYSCLK_CORE_CLOCK_MHZ-1), DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable, NULL
static TMR_ExtInit_TypeDef tmr0_config = {
//Частота Clk МГц, Период обновления
SYSCLK_CORE_CLOCK_MHZ, LOAD(0xFFFFFFFF, SYSCLK_CORE_CLOCK_MHZ-1),
//Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
};
#endif
#if USE_TMR1==1
static TMR_Init_TypeDef tmr1_config = {
// Частота Clk МГц, Период обновления Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование Коллбек
SYSCLK_CORE_CLOCK_MHZ, FREQ_HZ(10), DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable, NULL
static TMR_ExtInit_TypeDef tmr1_config = {
//Частота Clk МГц, Период обновления
SYSCLK_CORE_CLOCK_MHZ, FREQ_HZ(10),
//Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
};
#endif
#if USE_TMR2==1
static TMR_Init_TypeDef tmr2_config = {
// Частота Clk МГц, Период обновления Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование Коллбек
SYSCLK_CORE_CLOCK_MHZ, PERIOD_MKS(1000000),ENABLE, DISABLE, DISABLE, TMR_ExtInput_Disable, NULL
static TMR_ExtInit_TypeDef tmr2_config = {
//Частота Clk МГц, Период обновления
SYSCLK_CORE_CLOCK_MHZ, PERIOD_MKS(1000000),
//Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование
ENABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
};
#endif
#if USE_TMR3==1
static TMR_Init_TypeDef tmr3_config = {
// Частота Clk МГц, Период обновления Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование Коллбек
SYSCLK_CORE_CLOCK_MHZ, PERIOD_MKS(1000), DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable, NULL
//Частота Clk МГц, Период обновления
SYSCLK_CORE_CLOCK_MHZ, PERIOD_MKS(1000),
//Прерывания Запуск конверсии АЦП Реквест DMA Внешнее тактирование
DISABLE, DISABLE, DISABLE, TMR_ExtInput_Disable
};
#endif
//-- UART Конфигурации --------------------------------------------------------
#if USE_UART0==1
static UART_ExtInitTypeDef uart0_config = {
// Стоп биты, Четность, Длина посылки, Скорость, FIFO, Направление работы Коллбек Rx Коллбек Tx Коллбек IDLE Коллбек Error
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx, NULL, NULL, NULL, NULL,
//-- ADC SEQ Конфигурации -----------------------------------------------------
static RCU_PeriphClk_TypeDef ADC_ClockSource = RCU_PeriphClk_PLLClk;
static float ADC_ClockMHz = 12.5;
#if USE_ADC_SEQ0==1
static ADC_SEQ_ExtInit_TypeDef adc_seq0_config = {
//Событие запуска секвенсора, Разрешение программного запуска
ADC_SEQ_StartEvent_SwReq, ENABLE,
//Выбор каналов для запросов секвенсора
ADC_CH_Num_0, ADC_CH_Num_1, ADC_CH_Num_2, ADC_CH_Num_3,
//Последний запрос, Усреднение запросов, Усреднение запросов
ADC_SEQ_ReqNum_1, ADC_SEQ_Average_2, DISABLE,
//Кол-во рестартов секвенсора, Усреднение рестартов, Задержка между рестартами
0, DISABLE, 0,
//Разрешение каналов цифровых компараторов
DISABLE, DISABLE, DISABLE, DISABLE,
//Настройка DMA FIFO, Разрешение DMA
ADC_SEQ_DMAFIFOLevel_1, DISABLE,
//Прерывания, Количество запросов для прерывания
ENABLE, 0,
//SEQ Complete Коллбек, Error коллбек
NULL, NULL
};
#endif
#if USE_ADC_SEQ1==1
static ADC_SEQ_ExtInit_TypeDef adc_seq1_config = {
//Событие запуска секвенсора, Разрешение программного запуска
ADC_SEQ_StartEvent_SwReq, ENABLE,
//Выбор каналов для запросов секвенсора
ADC_CH_Num_0, ADC_CH_Num_1, ADC_CH_Num_2, ADC_CH_Num_3,
//Макс. кол-во запросов, Усреднение запросов, Усреднение запросов
ADC_SEQ_ReqNum_0, ADC_SEQ_Average_2, DISABLE,
//Кол-во рестартов секвенсора, Усреднение рестартов, Задержка между рестартами
0, DISABLE, 0,
//Разрешение каналов цифровых компараторов
DISABLE, DISABLE, DISABLE, DISABLE,
//Настройка DMA FIFO, Разрешение DMA
ADC_SEQ_DMAFIFOLevel_1, DISABLE,
//Прерывания, Количество запросов для прерывания
DISABLE, 0,
//SEQ Complete Коллбек, Error коллбек
NULL, NULL
};
#endif
#if USE_UART1==1
static UART_ExtInitTypeDef uart1_config = {
// Стоп биты, Четность, Длина посылки, Скорость, FIFO, Направление работы Коллбек Rx Коллбек Tx Коллбек IDLE Коллбек Error
UART_StopBit_1, UART_ParityBit_Disable, UART_DataWidth_8, 115200, DISABLE, UART_Direction_RxTx, NULL, NULL, NULL, NULL,
//-- ADC DC Конфигурации ------------------------------------------------------
#if USE_ADC_DC0==1
static ADC_DC_ExtInit_TypeDef adc_dc0_config = {
//Включение выхода компаратора
DISABLE,
//Нижний порог, Верхний порог
0, 0,
//Запуск измерения, Канал, Режим срабатывания, Условие срабатывания
ADC_DC_Source_EOC, ADC_CH_Num_1, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
//DC Triggered Коллбек, Error коллбек
NULL, NULL
};
#endif
#if USE_ADC_DC1==1
static ADC_DC_ExtInit_TypeDef adc_dc1_config = {
//Включение выхода компаратора
DISABLE,
//Нижний порог, Верхний порог
0, 0,
//Запуск измерения, Канал, Режим срабатывания, Условие срабатывания
ADC_DC_Source_EOC, ADC_CH_Num_2, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
//DC Triggered Коллбек, Error коллбек
NULL, NULL
};
#endif
#if USE_ADC_DC2==1
static ADC_DC_ExtInit_TypeDef adc_dc2_config = {
//Включение выхода компаратора
DISABLE,
//Нижний порог, Верхний порог
0, 0,
//Запуск измерения, Канал, Режим срабатывания, Условие срабатывания
ADC_DC_Source_EOC, ADC_CH_Num_3, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
//DC Triggered Коллбек, Error коллбек
NULL, NULL
};
#endif
#if USE_ADC_DC3==1
static ADC_DC_ExtInit_TypeDef adc_dc3_config = {
//Включение выхода компаратора
DISABLE,
//Нижний порог, Верхний порог
0, 0,
//Запуск измерения, Канал, Режим срабатывания, Условие срабатывания
ADC_DC_Source_EOC, ADC_CH_Num_4, ADC_DC_Mode_Multiple, ADC_DC_Condition_Low,
//DC Triggered Коллбек, Error коллбек
NULL, NULL
};
#endif
#endif /*__PERIPH_CONFIG_H*/