Razvalyaev/UKSI_TEST
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Чет работает

Browse Source
This commit is contained in:
Razvalyaev
2025-12-16 17:57:59 +03:00
commit 260a6416ad
2906 changed files with 982301 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
AllLibs/PeriphGeneral/Inc/__general_flash.h Normal file
View File

@@ -0,0 +1,44 @@
/**************************************************************************
* @file general_flash.h
* @brief Заголовочны файл модуля работы с FLASH.
*************************************************************************/
#ifndef __FLASH_GENERAL_H_
#define __FLASH_GENERAL_H_
//////////////////////////////////////////////////////////////////////
/////////////////////////---USER SETTINGS---/////////////////////////
/////////////////////////---USER SETTINGS---/////////////////////////
#include "mylibs_defs.h"
/////////////////////////////////////////////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////---STRUCTURES & ENUMS---//////////////////////
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
HAL_StatusTypeDef FLASH_Enable_DualBankMode(void);
HAL_StatusTypeDef FLASH_WriteProtection(uint32_t BankN, uint32_t WriteProtection);
/* functions for reading bytes/halswords/words */
uint8_t FLASH_Read_Byte(uint32_t add);
uint16_t FLASH_Read_HalfWord(uint32_t add);
uint32_t FLASH_Read_Word(uint32_t add);
/* functions for writing bytes/halswords/words */
HAL_StatusTypeDef FLASH_Write_Byte(uint32_t Address, uint8_t Data);
HAL_StatusTypeDef FLASH_Write_HalfWord(uint32_t Address, uint16_t Data);
HAL_StatusTypeDef FLASH_Write_Word(uint32_t Address, uint32_t Data);
///////////////////////////---FUNCTIONS---///////////////////////////
#endif // __FLASH_GENERAL_H_

238
AllLibs/PeriphGeneral/Inc/general_gpio.h Normal file
View File

@@ -0,0 +1,238 @@
/**
**************************************************************************
* @file general_gpio.h
* @brief Заголовочный файл для модуля инициализации портов и работы с ними.
**************************************************************************
* @defgroup GENERAL_GPIO GPIO Tools
* @ingroup STM32_GENERAL
* @brief Функции и макросы для удобной работы с GPIO.
* @details
Модуль предоставляет универсальные инструменты для работы с GPIO):
- @ref MYLIBS_GPIO_GENERAL — инициализация и общие функции работы с портами.
- @ref MYLIBS_GPIO_SWITCH — работа с GPIO как с кнопкой: чтение состояния,
фильтрация дребезга, настройка активного уровня.
- @ref MYLIBS_GPIO_LEDS — работа с GPIO как со светодиодом: включение,
выключение, моргание и плавное затухание.
*************************************************************************/
#ifndef __GPIO_GENERAL_H_
#define __GPIO_GENERAL_H_
#include "mylibs_defs.h"
/**
* @addtogroup GPIO_INIT GPIO Init defines
* @ingroup MYLIBS_GPIO_GENERAL
* @ingroup GENERAL_CONFIGS Конфигурации STM32 General
* @brief Настройка состояний кнопок и количества тиков в периоде ШИМ
* @{
*/
#ifndef local_time
#define local_time() HAL_GetTick() ///< Локальное время
#endif
#ifndef LED_PWM_TICKS
#define LED_PWM_TICKS 15 ///< Количество тиков в периоде ШИМ
#endif
#ifndef LED_ON
#define LED_ON 1 ///< Состояние пина для включения светодиода
#endif
#ifndef LED_OFF
#define LED_OFF 0 ///< Состояние пина для выключения светодиода
#endif
#ifndef SW_ON
#define SW_ON 1 ///< Состояние пина при нажатой кнопке
#endif
#ifndef SW_OFF
#define SW_OFF 0 ///< Состояние пина при отжатой кнопке
#endif
/** GPIO_INIT
* @}
*/
/**
* @brief Режимы работы светодиода
* @ingroup MYLIBS_GPIO_LEDS
*/
typedef enum
{
LED_IS_OFF = 0, ///< Светодиод выключен
LED_IS_ON = 1, ///< Светодиод включен
LED_IS_BLINKING = 2, ///< Моргание светодиодом
LED_IS_FADING = 3, ///< Плавное моргание светодиодом
}GPIO_LEDStateTypeDef;
/**
* @brief Структура светодиода
* @ingroup MYLIBS_GPIO_LEDS
*/
typedef struct
{
GPIO_LEDStateTypeDef state; ///< Текущий режим работы светодиода
GPIO_TypeDef *LED_Port; ///< GPIO порт ножки светодиода
uint32_t LED_Pin; ///< GPIO пин ножки светодиода
uint8_t LED_ActiveLvl; ///< Активный уровень ножки (при котором светодиод горит)
uint32_t LED_Period; ///< Период моргания светодиода
uint32_t tickprev;
}GPIO_LEDTypeDef;
/**
* @brief Структура кнопки
* @ingroup MYLIBS_GPIO_SWITCH
*/
typedef struct
{
GPIO_TypeDef *Sw_Port; ///< GPIO порт ножки кнопки
uint32_t Sw_Pin; ///< GPIO пин ножки кнопки
uint8_t Sw_ActiveLvl; ///< Активный уровень ножки (при котором кнопка нажата)
uint32_t Sw_CurrentState; ///< Текущее состояние кнопки
uint32_t Sw_FilterDelay; ///< Фильтр от дребезга (в мс)
uint32_t tickprev;
}GPIO_SwitchTypeDef;
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
/**
* @addtogroup MYLIBS_GPIO_GENERAL General tools
* @ingroup GENERAL_GPIO
* @brief Общие функции/макросы для работы с GPIO
* @par Пример использования:
@code
// Включаем тактирование порта GPIOA
GPIO_Clock_Enable(GPIOA);
@endcode
* @{
*/
HAL_StatusTypeDef GPIO_Clock_Enable(GPIO_TypeDef *GPIOx);
/** MYLIBS_GPIO_GENERAL
* @}
*/
/**
* @addtogroup MYLIBS_GPIO_SWITCH Switch tools
* @ingroup GENERAL_GPIO
* @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
* @{
*/
/* Инициализировать кнопку (структуру кнопки) */
HAL_StatusTypeDef GPIO_Switch_Init(GPIO_SwitchTypeDef *sw, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, uint8_t SW_On_State);
/* Считать состоянии кнопки запуска */
int GPIO_Read_Switch(GPIO_SwitchTypeDef *swstart);
/** MYLIBS_GPIO_SWITCH
* @}
*/
/**
* @addtogroup MYLIBS_GPIO_LEDS LED tools
* @ingroup GENERAL_GPIO
* @brief Функции для работы с GPIO, для управления светодиодом
* @par Пример использования:
@code
MX_GPIO_Init(); // инициализация пина аппаратная
// Инициализация светодиода на порте 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
* @{
*/
/* Инициализировать светодиод (структуру светодиода) */
HAL_StatusTypeDef GPIO_LED_Init(GPIO_LEDTypeDef *led, GPIO_TypeDef *GPIOx, uint32_t GPIO_PIN_X, uint8_t LED_On_State);
/* Включить светодиод */
HAL_StatusTypeDef GPIO_LED_On (GPIO_LEDTypeDef *led);
/* Выключить светодиод */
HAL_StatusTypeDef GPIO_LED_Off (GPIO_LEDTypeDef *led);
/* Выставить светодиод по переменной */
HAL_StatusTypeDef GPIO_LED_Set (GPIO_LEDTypeDef *led, uint8_t led_state);
/* Активировать моргание светодиодом */
HAL_StatusTypeDef GPIO_LED_Blink_Start (GPIO_LEDTypeDef *led, uint32_t period);
/* Активировать моргание светодиодом */
HAL_StatusTypeDef GPIO_LED_Fading_Start(GPIO_LEDTypeDef *led, uint32_t period);
/* Управление динамическими режимами свечения светодиода */
void GPIO_LED_Dynamic_Handle(GPIO_LEDTypeDef *led);
/** MYLIBS_GPIO_LEDS
* @}
*/
///////////////////////////---FUNCTIONS---///////////////////////////
/**
* @cond GPIO_INTERNAL
*/
// /**
// * @brief Маппинг альтернативной функции SPI между GPIO
// * @ingroup MYLIBS_GPIO_GENERAL
// */
// #define SPI_Alternate_Mapping(INSTANCE) \
// ((((INSTANCE) == TIM1) || ((INSTANCE) == TIM2))? GPIO_AF1_TIM1: \
// (((INSTANCE) == TIM3) || ((INSTANCE) == TIM4) || ((INSTANCE) == TIM5))? GPIO_AF2_TIM3: \
// (((INSTANCE) == TIM8) || ((INSTANCE) == TIM9) || ((INSTANCE) == TIM10) || ((INSTANCE) == TIM11))? GPIO_AF3_TIM8: \
// (((INSTANCE) == TIM12) || ((INSTANCE) == TIM13) || ((INSTANCE) == TIM14))? GPIO_AF9_TIM12: \
// (0))
/**
* @brief Маппинг альтернативной функции TIM между GPIO
* @ingroup MYLIBS_GPIO_GENERAL
*/
#define GPIO_TIM_Alternate_Mapping(INSTANCE) \
((((INSTANCE) == TIM1) || ((INSTANCE) == TIM2))? GPIO_AF1_TIM1: \
(((INSTANCE) == TIM3) || ((INSTANCE) == TIM4) || ((INSTANCE) == TIM5))? GPIO_AF2_TIM3: \
(((INSTANCE) == TIM8) || ((INSTANCE) == TIM9) || ((INSTANCE) == TIM10) || ((INSTANCE) == TIM11))? GPIO_AF3_TIM8: \
(((INSTANCE) == TIM12) || ((INSTANCE) == TIM13) || ((INSTANCE) == TIM14))? GPIO_AF9_TIM12: \
(0))
/** @endcond */
#endif // __GPIO_GENERAL_H_

171
AllLibs/PeriphGeneral/Inc/general_spi.h Normal file
View File

@@ -0,0 +1,171 @@
/**
**************************************************************************
* @file general_spi.h
* @brief Заголовочный файл для модуля инициализации SPI.
**************************************************************************
* @defgroup GENERAL_SPI SPI Tools
* @ingroup STM32_GENERAL
* @brief Функции и макросы для удобной работы с SPI.
* @details
Модуль предоставляет функции для базовой инициализации SPI
@par Пример использования:
@code
// Структура настроек SPI
SPI_SettingsTypeDef spi1Settings;
void SPI1_Init(void)
{
// Настройка SPI1 как Master, 8 бит, полный дуплекс
spi1Settings.hspi.Instance = SPI1;
spi1Settings.hspi.Init.Mode = SPI_MODE_MASTER;
spi1Settings.hspi.Init.Direction = SPI_DIRECTION_2LINES;
spi1Settings.hspi.Init.DataSize = SPI_DATASIZE_8BIT;
spi1Settings.hspi.Init.CLKPolarity = SPI_POLARITY_LOW;
spi1Settings.hspi.Init.CLKPhase = SPI_PHASE_1EDGE;
spi1Settings.hspi.Init.NSS = SPI_NSS_SOFT;
spi1Settings.hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
spi1Settings.hspi.Init.FirstBit = SPI_FIRSTBIT_MSB;
spi1Settings.hspi.Init.TIMode = SPI_TIMODE_DISABLE;
spi1Settings.hspi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
// Настройка GPIO
spi1Settings.CLK_GPIOx = GPIOA;
spi1Settings.CLK_PIN = GPIO_PIN_5;
spi1Settings.CLK_GPIO_AlternageFunc = GPIO_AF5_SPI1;
spi1Settings.MISO_GPIOx = GPIOA;
spi1Settings.MISO_PIN = GPIO_PIN_6;
spi1Settings.MISO_GPIO_AlternageFunc = GPIO_AF5_SPI1;
spi1Settings.MOSI_GPIOx = GPIOA;
spi1Settings.MOSI_PIN = GPIO_PIN_7;
spi1Settings.MOSI_GPIO_AlternageFunc = GPIO_AF5_SPI1;
// Инициализация SPI
if(SPI_Base_Init(&spi1Settings) != HAL_OK)
{
// Обработка ошибки
Error_Handler();
}
}
@endcode
* @note Требуется подключение модуля SPI в библиотеке HAL
@code
#define HAL_SPI_MODULE_ENABLED
@endcode
* @{
*************************************************************************/
#ifndef __SPI_GENERAL_H_
#define __SPI_GENERAL_H_
/////////////////////////////////////////////////////////////////////
/////////////////////////---USER SETTINGS---/////////////////////////
/**
* @addtogroup SPI_INIT SPI Init defines
* @ingroup GENERAL_SPI
* @ingroup GENERAL_CONFIGS Конфигурации STM32 General
* @brief Настройка SPI
* @{
*/
#define HAL_SPI_MODULE_ENABLED ///< Включение HAL SPI
#define USE_SPI1 ///< Включить SPI1 в @ref SPI_MspInit
#define USE_SPI2 ///< Включить SPI2 в @ref SPI_MspInit
#define USE_SPI3 ///< Включить SPI3 в @ref SPI_MspInit
/** SPI_INIT
* @}
*/
/////////////////////////---USER SETTINGS---/////////////////////////
#include "mylibs_defs.h"
/////////////////////////////////////////////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/**
* @brief Структура настроек SPI
* @details Содержит все необходимые параметры для инициализации SPI,
* включая GPIO и DMA.
*/
typedef struct
{
SPI_HandleTypeDef hspi; ///< HAL handle SPI
GPIO_TypeDef *CLK_GPIOx; ///< Порт CLK
uint32_t CLK_PIN; ///< Пин CLK
uint32_t CLK_GPIO_AlternageFunc; ///< Альтернативная функция для CLK
GPIO_TypeDef *MISO_GPIOx; ///< Порт MISO
uint32_t MISO_PIN; ///< Пин MISO
uint32_t MISO_GPIO_AlternageFunc; ///< Альтернативная функция для MISO
GPIO_TypeDef *MOSI_GPIOx; ///< Порт MOSI
uint32_t MOSI_PIN; ///< Пин MOSI
uint32_t MOSI_GPIO_AlternageFunc; ///< Альтернативная функция для MOSI
DMA_Stream_TypeDef *DMAChannel; ///< Канал DMA (NULL если не нужен)
uint32_t DMA_CHANNEL_X; ///< Номер канала DMA (0 если не нужен)
} SPI_SettingsTypeDef;
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
/* Инициализация SPI с использованием структуры настроек */
HAL_StatusTypeDef SPI_Base_Init(SPI_SettingsTypeDef *sspi);
/* Проверка корректности структуры настроек SPI */
HAL_StatusTypeDef SPI_Check_Init_Struct(SPI_SettingsTypeDef *sspi);
/* Инициализация тактирования и прерываний для выбранного SPI */
void SPI_MspInit(SPI_HandleTypeDef *hspi);
/* Деинициализация тактирования и прерываний для выбранного SPI */
void SPI_MspDeInit(SPI_HandleTypeDef *hspi);
/**
* @cond SPI_INTERNAL
*/
/* Настройка GPIO для SPI */
void SPI_GPIO_Init(SPI_SettingsTypeDef *sspi);
/* Настройка DMA для SPI */
void SPI_DMA_Init(SPI_HandleTypeDef *hspi, DMA_HandleTypeDef *hdma_rx, DMA_Stream_TypeDef *DMAChannel, uint32_t DMA_CHANNEL_X);
#ifndef __USER_LINKDMA
/**
* @brief Аналог HAL макроса для привязки DMA к UART.
* @note @ref __HAL_LINKDMA.
*/
#define __USER_LINKDMA(__HANDLE__, __PPP_DMA_FIELD__, __DMA_HANDLE__) \
do{ \
(__HANDLE__)->__PPP_DMA_FIELD__ = (__DMA_HANDLE__); \
(__DMA_HANDLE__)->Parent = (__HANDLE__);} while(0U)
#endif
/** @endcond */
///////////////////////////---FUNCTIONS---///////////////////////////
#endif // __SPI_GENERAL_H_
/** GENERAL_SPI
* @}
*/

351
AllLibs/PeriphGeneral/Inc/general_tim.h Normal file
View File

@@ -0,0 +1,351 @@
/**
**************************************************************************
* @file general_tim.h
* @brief Заголовочный файл для модуля инициализации таймеров и работы с ними.
**************************************************************************
* @defgroup GENERAL_TIM TIM Tools
* @ingroup STM32_GENERAL
* @brief Функции и макросы для удобной работы с TIM.
* @details
Модуль предоставляет универсальные инструменты для работы с TIM:
- @ref MYLIBS_TIM_GENERAL — базовая инициализация таймеров и прерываний.
- @ref MYLIBS_TIM_DELAY — функции задержки через таймеры (blocking и non-blocking).
- @ref MYLIBS_TIM_OC — настройка каналов Output Compare и PWM.
- @ref MYLIBS_TIM_ENCODER — работа с энкодерами, чтение положения и кнопки.
* @note Требуется подключение модуля TIM в библиотеке HAL и GPIO (@ref GENERAL_GPIO) из MyLibs
@code
#define HAL_TIM_MODULE_ENABLED
@endcode
*************************************************************************/
#ifndef __TIM_GENERAL_H_
#define __TIM_GENERAL_H_
/////////////////////////////////////////////////////////////////////
/////////////////////////---USER SETTINGS---/////////////////////////
/**
* @addtogroup TIM_INIT TIM Init defines
* @ingroup MYLIBS_TIM_GENERAL
* @ingroup GENERAL_CONFIGS Конфигурации STM32 General
* @brief Настройка таймеров
* @{
*/
#define HAL_TIM_MODULE_ENABLED
#define USE_TIM1 ///< Включить TIM1 в @ref TIM_Base_MspInit
#define USE_TIM2 ///< Включить TIM2 в @ref TIM_Base_MspInit
#define USE_TIM3 ///< Включить TIM3 в @ref TIM_Base_MspInit
#define USE_TIM4 ///< Включить TIM4 в @ref TIM_Base_MspInit
#define USE_TIM5 ///< Включить TIM5 в @ref TIM_Base_MspInit
#define USE_TIM6 ///< Включить TIM6 в @ref TIM_Base_MspInit
#define USE_TIM7 ///< Включить TIM7 в @ref TIM_Base_MspInit
#define USE_TIM8 ///< Включить TIM8 в @ref TIM_Base_MspInit
#define USE_TIM9 ///< Включить TIM9 в @ref TIM_Base_MspInit
#define USE_TIM10 ///< Включить TIM10 в @ref TIM_Base_MspInit
#define USE_TIM11 ///< Включить TIM11 в @ref TIM_Base_MspInit
#define USE_TIM12 ///< Включить TIM12 в @ref TIM_Base_MspInit
#define USE_TIM13 ///< Включить TIM13 в @ref TIM_Base_MspInit
#define USE_TIM14 ///< Включить TIM14 в @ref TIM_Base_MspInit
/** TIM_INIT
* @}
*/
/////////////////////////---USER SETTINGS---/////////////////////////
#include "mylibs_defs.h"
#include "general_gpio.h"
/////////////////////////////////////////////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
#define TIM_IT_CONF_Pos 0
//#define TIM_PWM_CONF_Pos 1
//#define TIM_CLCK_SRC_CONF_Pos 2
//#define TIM_SLAVE_CONF_Pos 3
//#define TIM_MASTER_CONF_Pos 4
//#define TIM_BDTR_CONF_Pos 5
#define TIM_IT_CONF (1<<(TIM_IT_CONF_Pos))
//#define TIM_PWM_CONF (1<<(TIM_PWM_Pos))
////////////////////////////---DEFINES---////////////////////////////]
/////////////////////////////////////////////////////////////////////
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/**
* @brief Режим прерываний таймера
* @ingroup MYLIBS_TIM_GENERAL
*/
typedef enum
{
TIM_DEFAULT = 0, ///< Прерываний отключены
TIM_IT_MODE = TIM_IT_CONF, ///< Прерываний включены
// TIM_PWM_MODE = TIM_PWM_ENABLE,
// TIM_PWM_IT_MODE = TIM_PWM_ENABLE | TIM_IT_CONF,
}TIM_ITModeTypeDef;
/**
* @brief Длительность тика таймера (частота тактирования таймера)
* @ingroup MYLIBS_TIM_GENERAL
* @details enum дает базовые длительности, но можно выставить другие
* (напр 500 - 0.5 мс)
*/
typedef enum
{
TIM_Base_Disable = 0, ///< Таймер отключен
TIM_TickBase_1US = 1, ///< Таймер тактируется с частотой 1 МГц
TIM_TickBase_10US = 10, ///< Таймер тактируется с частотой 100 кГц
TIM_TickBase_100US = 100, ///< Таймер тактируется с частотой 10 кГц
TIM_TickBase_1MS = 1000, ///< Таймер тактируется с частотой 1 кГц
TIM_TickBase_10MS = 10000, ///< Таймер тактируется с частотой 100 Гц
TIM_TickBase_100MS = 100000, ///< Таймер тактируется с частотой 10 Гц
}TIM_MHzTickBaseTypeDef;
/**
* @brief Структура инициализации таймера
* @ingroup MYLIBS_TIM_GENERAL
* @details
* Содержит все базовые структуры, которые нужны для инициализации таймера.
* Если структуры настроек не заданы, то они заполнятся сами дефолтными параметрами
*
* Также высокоуровневые настройки частоты работы таймера.
* Если какая-либо высокоуровневая настройка не задана, то
* по возможности берется низкоуровневая настройка из структур
*/
typedef struct // struct with settings for custom function
{
TIM_HandleTypeDef htim; ///< HAL handle таймера
TIM_ClockConfigTypeDef sClockSourceConfig; ///< Настройки тактирования таймера
TIM_SlaveConfigTypeDef sSlaveConfig; ///< Настройки слейв режима таймера
TIM_MasterConfigTypeDef sMasterConfig; ///< Настройки мастер режима таймера
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig; ///< Настройки дедтаймов таймера
TIM_ITModeTypeDef sTimMode; ///< Настройки прерывания таймера
TIM_MHzTickBaseTypeDef sTickBaseUS; ///< Длительность одного тика
uint8_t sTickBasePrescaler; ///< Дополнительный делитель, для удобного деления @ref sTickBaseUS
float sTimAHBFreqMHz; ///< Частота шины тактирования таймера
float sTimFreqHz; ///< Желаемая частота таймера
}TIM_SettingsTypeDef;
/**
* @brief Структура инициализации енкодера
* @ingroup MYLIBS_TIM_ENCODER
* @details
* Содержит все базовые структуры, которые нужны для инициализации таймера.
* Если структуры настроек не заданы, то они заполнятся сами дефолтными параметрами
*
* Также высокоуровневые настройки частоты работы таймера.
* Если какая-либо высокоуровневая настройка не задана, то
* по возможности берется низкоуровневая настройка из структур
*/
typedef struct // struct with variables for encoder
{
int16_t Encoder_Diff; ///< Считанная разница
uint16_t Encoder_Shdw; ///< Последние считанные тики
TIM_HandleTypeDef *htim; ///< Указатель на HAL handle таймера
TIM_Encoder_InitTypeDef sConfig; ///< Указатель на структуру настройки энкодера
GPIO_TypeDef *GPIOx; ///< Порт, куда подключается энкодер
uint32_t GPIO_PIN_TI1; ///< Пин, куда подключается канал TI1
uint32_t GPIO_PIN_TI2; ///< Пин, куда подключается канал TI2
uint32_t GPIO_PIN_SW; ///< Пин, куда кнопка энкодера (если есть)
GPIO_SwitchTypeDef Sw; ///< Структура кнопки
}TIM_EncoderTypeDef;
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
/**
* @addtogroup MYLIBS_TIM_GENERAL General tools
* @ingroup GENERAL_TIM
* @brief Функции для базовой инициализации таймеров
* @par Пример использования:
@code
TIM_SettingsTypeDef tim2Settings;
void TIM2_Init(void)
{
// Настройка таймера TIM2 на 1 кГц с прерываниями с шагом таймера 10 мкс
tim2Settings.htim.Instance = TIM2;
tim2Settings.sTimMode = TIM_IT_MODE;
tim2Settings.sTickBaseUS = TIM_TickBase_10US;
tim2Settings.sTickBasePrescaler = 1;
tim2Settings.sTimFreqHz = 1000; // 1 кГц
tim2Settings.sTimAHBFreqMHz = 72000000; // Hz
if(TIM_Base_Init(&tim2Settings) != HAL_OK)
{
Error_Handler();
}
}
@endcode
* @{
*/
/**
* @brief Преобразование частоты в количество тиков таймера.
* @param _freq_ Желаемая частота в Гц.
* @param _timfreqMHz_ Тактовая частота таймера в МГц.
* @return Количество тиков для достижения заданной частоты.
* @details Расчет: (1 000 000 * частота_таймера) / желаемая_частота.
*/
#define TIM_FreqToTick(_freq_, _timfreqMHz_) (((1000000*(_timfreqMHz_))/(_freq_))-1)
/**
* @brief Преобразование миллисекунд в количество тиков таймера.
* @param _ms_ Время в миллисекундах.
* @param _timfreqMHz_ Тактовая частота таймера в МГц.
* @return Количество тиков для заданного времени.
* @details Расчет: (мс * 1000 * частота_таймера).
*/
#define TIM_MillisToTick(_ms_, _timfreqMHz_) (((uint32_t)((_ms_) * 1000UL * (_timfreqMHz_)))-1)
/**
* @brief Преобразование микросекунд в количество тиков таймера.
* @param _us_ Время в микросекундах.
* @param _timfreqMHz_ Тактовая частота таймера в МГц.
* @return Количество тиков для заданного времени.
* @details Расчет: (мкс * частота_таймера).
*/
#define TIM_MicrosToTick(_us_, _timfreqMHz_) (((uint32_t)((_us_) * (_timfreqMHz_)))-1)
/**
* @brief Установка автоперезагрузки (ARR) с принудительным обновлением теневого регистра.
* @param __HANDLE__ Указатель на хендл таймера.
* @param __AUTORELOAD__ Значение автоперезагрузки.
* @details Генерирует событие обновления для немедленного применения нового значения ARR.
* Решает проблему обновления теневых регистров только при переполнении.
*/
#define __HAL_TIM_SET_AUTORELOAD_FORCE(__HANDLE__, __AUTORELOAD__) \
do{ __HAL_TIM_SET_AUTORELOAD(__HANDLE__, __AUTORELOAD__); \
HAL_TIM_GenerateEvent(__HANDLE__, TIM_EVENTSOURCE_UPDATE); } while(0);
/**
* @brief Установка предделителя (PSC) с принудительным обновлением теневого регистра.
* @param __HANDLE__ Указатель на хендл таймера.
* @param __PRESC__ Значение предделителя.
* @details Генерирует событие обновления для немедленного применения нового значения PSC.
* Решает проблему обновления теневых регистров только при переполнении.
*/
#define __HAL_TIM_SET_PRESCALER_FORCE(__HANDLE__, __PRESC__) \
do{ __HAL_TIM_SET_PRESCALER(__HANDLE__, __PRESC__); \
HAL_TIM_GenerateEvent(__HANDLE__, TIM_EVENTSOURCE_UPDATE); } while(0);
/* Initialize TIM with TIM_SettingsTypeDef structure */
HAL_StatusTypeDef TIM_Base_Init(TIM_SettingsTypeDef* stim);
/* Initialize TIMs clock and interrupt */
void TIM_Base_MspInit(TIM_HandleTypeDef* htim, TIM_ITModeTypeDef it_mode);
/* DeInitialize TIMs clock and interrupt */
void TIM_Base_MspDeInit(TIM_HandleTypeDef* htim);
/** MYLIBS_TIM_GENERAL
* @}
*/
/**
* @addtogroup MYLIBS_TIM_DELAY Delay tools
* @ingroup GENERAL_TIM
* @brief Функции для формирования задержек с помощью таймеров
* @par Пример использования:
@code
TIM_HandleTypeDef htim2;
// блокирующая задержка 500 тиков таймера
LED_ON();
TIM_Delay(&htim2, 500);
LED_OFF();
while(1)
{
// не блокирующая задержка 200 тиков таймера
if(TIM_Delay_NonBlocking(&htim2, 200) == HAL_OK)
{
TIM_Delay_Start(&htim2);
LED_TOOGLE();
}
}
@endcode
* @{
*/
/* Start delay via TIM */
HAL_StatusTypeDef TIM_Delay_Start(TIM_HandleTypeDef *htim);
/* Delay via TIM */
HAL_StatusTypeDef TIM_Delay(TIM_HandleTypeDef *htim, uint16_t delay);
/* Wait Delay via TIM without blocking app */
HAL_StatusTypeDef TIM_Delay_NonBlocking(TIM_HandleTypeDef *htim, uint16_t delay);
/** MYLIBS_TIM_DELAY
* @}
*/
/**
* @addtogroup MYLIBS_TIM_OC PWM/OC Channels tools
* @ingroup GENERAL_TIM
* @brief Функции для инициализации базовых функций каналов таймера
* @par Пример использования:
@code
void PWM_Channel_Init_Example(void)
{
TIM_HandleTypeDef htim3;
TIM_OC_InitTypeDef sConfigOC;
GPIO_TypeDef *GPIOx = GPIOB;
uint32_t PWM_PIN = GPIO_PIN_0;
// Настройка таймера и канала PWM
TIM_Output_PWM_Init(&htim3, &sConfigOC, TIM_CHANNEL_1, GPIOx, PWM_PIN);
// Настройка компаратора OC
TIM_OC_Comparator_Init(&htim3, TIM_CHANNEL_1);
}
@endcode
* @{
*/
/* Initialize PWM Channel and GPIO for output */
HAL_StatusTypeDef TIM_Output_PWM_Init(TIM_HandleTypeDef *htim, TIM_OC_InitTypeDef *sConfigOC, uint32_t TIM_CHANNEL, GPIO_TypeDef *GPIOx, uint32_t PWM_PIN);
/* Initialize OC Comparator */
HAL_StatusTypeDef TIM_OC_Comparator_Init(TIM_HandleTypeDef *htim, uint32_t TIM_CHANNEL);
/** MYLIBS_TIM_ENCODER
* @}
*/
/**
* @addtogroup MYLIBS_TIM_ENCODER Encoder tools
* @ingroup GENERAL_TIM
* @brief Функции для считывания энкодера
* @par Пример использования:
@code
TIM_EncoderTypeDef henc1;
TIM_HandleTypeDef htim4;
// инициализация
henc1.htim = &htim4;
henc1.GPIOx = GPIOA;
henc1.GPIO_PIN_TI1 = GPIO_PIN_0;
henc1.GPIO_PIN_TI2 = GPIO_PIN_1;
TIM_Encoder_Init(&henc1, &htim4);
// считывание энкодера и кнопки
int16_t delta = TIM_Encoder_Read(&henc1);
setpoint_tmp += delta;
if(TIM_Encoder_ReadSwitch(&henc1))
{
setpoint = setpoint_tmp; // подтвердить новое значение
}
@endcode
* @{
*/
/* Initialize TIM Encoder functional */
HAL_StatusTypeDef TIM_Encoder_Init(TIM_EncoderTypeDef *henc1, TIM_HandleTypeDef *htim);
/* Считать энкодер */
HAL_StatusTypeDef TIM_Encoder_Read(TIM_EncoderTypeDef *henc);
/* Считать кнопку энкодера */
int TIM_Encoder_ReadSwitch(TIM_EncoderTypeDef *henc);
/** MYLIBS_TIM_ENCODER
* @}
*/
///////////////////////////---FUNCTIONS---///////////////////////////
#endif // __TIM_GENERAL_H_

157
AllLibs/PeriphGeneral/Inc/general_uart.h Normal file
View File

@@ -0,0 +1,157 @@
/**
**************************************************************************
* @file general_uart.h
* @brief Заголовочный файл для модуля инициализации UART.
**************************************************************************
* @defgroup GENERAL_UART UART Tools
* @ingroup STM32_GENERAL
* @brief Функции и макросы для удобной работы с UART.
* @details
Модуль предоставляет функции для базовой инициализации UART
@par Пример использования:
@code
// Структура настроек UART
UART_SettingsTypeDef uart2Settings;
void UART2_Init(void)
{
// Настройка UART2 с 115200 бод, 8 бит, 1 стоп-бит, без паритета
uart2Settings.huart.Instance = USART2;
uart2Settings.huart.Init.BaudRate = 115200;
uart2Settings.huart.Init.WordLength = UART_WORDLENGTH_8B;
uart2Settings.huart.Init.StopBits = UART_STOPBITS_1;
uart2Settings.huart.Init.Parity = UART_PARITY_NONE;
uart2Settings.huart.Init.Mode = UART_MODE_TX_RX;
uart2Settings.huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
uart2Settings.huart.Init.OverSampling = UART_OVERSAMPLING_16;
// Настройка GPIO
uart2Settings.GPIOx = GPIOA;
uart2Settings.GPIO_PIN_TX = GPIO_PIN_2;
uart2Settings.GPIO_PIN_RX = GPIO_PIN_3;
// DMA не используется в этом примере
uart2Settings.DMAChannel = NULL;
uart2Settings.DMA_CHANNEL_X = 0;
// Инициализация UART
if(UART_Base_Init(&uart2Settings) != HAL_OK)
{
// Обработка ошибки
Error_Handler();
}
}
@endcode
* @note Требуется подключение модуля UART в библиотеке HAL
@code
#define HAL_UART_MODULE_ENABLED
@endcode
* @{
*************************************************************************/
#ifndef __UART_GENERAL_H_
#define __UART_GENERAL_H_
/////////////////////////////////////////////////////////////////////
/////////////////////////---USER SETTINGS---/////////////////////////
/**
* @addtogroup UART_INIT UART Init defines
* @ingroup GENERAL_UART
* @ingroup GENERAL_CONFIGS Конфигурации STM32 General
* @brief Настройка UART
* @{
*/
#define HAL_UART_MODULE_ENABLED ///< Включение HAL UART
#define USE_USART1 ///< Включить USART1 в @ref UART_MspInit
#define USE_USART2 ///< Включить USART2 в @ref UART_MspInit
#define USE_USART3 ///< Включить USART3 в @ref UART_MspInit
#define USE_UART4 ///< Включить UART4 в @ref UART_MspInit
#define USE_UART5 ///< Включить UART5 в @ref UART_MspInit
#define USE_USART6 ///< Включить USART6 в @ref UART_MspInit
/** UART_INIT
* @}
*/
/////////////////////////---USER SETTINGS---/////////////////////////
#include "mylibs_defs.h"
/////////////////////////////////////////////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
////////////////////////////---DEFINES---////////////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/**
* @brief Структура настроек UART
* @details Содержит все необходимые параметры для инициализации UART,
* включая GPIO и DMA.
*/
typedef struct
{
UART_HandleTypeDef huart; ///< HAL handle UART
GPIO_TypeDef *GPIOx; ///< Порт для UART
uint16_t GPIO_PIN_RX; ///< Пин приема
uint16_t GPIO_PIN_TX; ///< Пин передачи
DMA_Stream_TypeDef *DMAChannel; ///< Канал DMA (NULL если не нужен)
uint32_t DMA_CHANNEL_X; ///< Номер канала DMA (0 если не нужен)
} UART_SettingsTypeDef;
///////////////////////---STRUCTURES & ENUMS---//////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
/* Инициализация UART с использованием структуры настроек */
HAL_StatusTypeDef UART_Base_Init(UART_SettingsTypeDef *suart);
/* Проверка корректности структуры настроек UART */
HAL_StatusTypeDef UART_Check_Init_Struct(UART_SettingsTypeDef *suart);
/* Инициализация тактирования и прерываний для выбранного UART */
void UART_MspInit(UART_HandleTypeDef *huart);
/* Деинициализация тактирования и прерываний для выбранного UART */
void UART_MspDeInit(UART_HandleTypeDef *huart);
/**
* @cond UART_INTERNAL
*/
/* Настройка GPIO для UART */
void UART_GPIO_Init(GPIO_TypeDef *GPIOx, uint16_t GPIO_PIN_RX, uint16_t GPIO_PIN_TX);
/* Настройка DMA для UART */
void UART_DMA_Init(UART_HandleTypeDef *huart, DMA_HandleTypeDef *hdma_rx, DMA_Stream_TypeDef *DMAChannel, uint32_t DMA_CHANNEL_X);
#ifndef __USER_LINKDMA
/**
* @brief Аналог HAL макроса для привязки DMA к UART.
* @note @ref __HAL_LINKDMA.
*/
#define __USER_LINKDMA(__HANDLE__, __PPP_DMA_FIELD__, __DMA_HANDLE__) \
do{ \
(__HANDLE__)->__PPP_DMA_FIELD__ = (__DMA_HANDLE__); \
(__DMA_HANDLE__)->Parent = (__HANDLE__);} while(0U)
#endif
/** @endcond */
///////////////////////////---FUNCTIONS---///////////////////////////
#endif // __UART_GENERAL_H_
/** GENERAL_UART
* @}
*/