void Uart2DMAInit(UART_HandleTypeDef* huart) {
__DMA1_CLK_ENABLE()
;
huart->hdmatx = (DMA_HandleTypeDef*) calloc(1, sizeof(DMA_HandleTypeDef));
REQUIRE(huart->hdmatx!=0);
huart->hdmatx->Instance = DMA1_Stream6;
huart->hdmatx->Init.Channel = DMA_CHANNEL_4;
huart->hdmatx->Init.Direction = DMA_MEMORY_TO_PERIPH;
huart->hdmatx->Init.PeriphInc = DMA_PINC_DISABLE;
huart->hdmatx->Init.MemInc = DMA_MINC_ENABLE;
huart->hdmatx->Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
huart->hdmatx->Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
huart->hdmatx->Init.Mode = DMA_NORMAL;
huart->hdmatx->Init.Priority = DMA_PRIORITY_LOW;
huart->hdmatx->Init.FIFOMode = DMA_FIFOMODE_DISABLE;
huart->hdmatx->Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
huart->hdmatx->Init.MemBurst = DMA_MBURST_SINGLE;
huart->hdmatx->Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(huart->hdmatx);
huart->hdmatx->Parent = huart;
HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
}
void Init_DMA_UART3_RX(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
/* Peripheral DMA init*/
hdma_uart_rx.Instance = DMA1_Channel3;
hdma_uart_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdma_uart_rx.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_uart_rx.Init.MemInc = DMA_MINC_ENABLE;
hdma_uart_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
hdma_uart_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
hdma_uart_rx.Init.Mode = DMA_CIRCULAR;
hdma_uart_rx.Init.Priority = DMA_PRIORITY_VERY_HIGH;
HAL_DMA_Init(&hdma_uart_rx);
HAL_DMA_Start(&hdma_uart_rx, (uint32_t)&(huart3.Instance->DR),(uint32_t)dma_rx_buffer,DMA_RX_BUFFER_LENGTH);
/* Enable the UART DMA Rx request */
SET_BIT(huart3.Instance->CR3, USART_CR3_DMAR);
// __HAL_DMA_ENABLE()
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
/* DMA interrupt init */
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
__DMA2_CLK_ENABLE();
/* DMA interrupt init */
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 8, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream4_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream4_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn);
/* Sets the priority grouping field */
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 7, 0);
HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
// /* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Channel4_5_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel4_5_IRQn);
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void) {
/* DMA controller clock enable */
__DMA1_CLK_ENABLE()
;
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 4, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
__DMA2_CLK_ENABLE();
DownlinkDMA1_Init();
DownlinkDMA2_Init();
DownlinkDMA3_Init();
DownlinkDMA4_Init();
UplinkDMA1_Init();
UplinkDMA2_Init();
}
/**
* @brief TIM MSP Initialization
* This function configures the hardware resources used in this example:
* - Peripheral's clock enable
* - Peripheral's GPIO Configuration
* - DMA configuration for transmission request by peripheral
* @param htim: TIM handle pointer
* @retval None
*/
void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitStruct;
static DMA_HandleTypeDef hdma_tim;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* TIM2 clock enable */
__TIM2_CLK_ENABLE();
/* Enable GPIO TIM2_Channel3 (PORTB) Clock */
__GPIOA_CLK_ENABLE();
/* Enable DMA1 clock */
__DMA1_CLK_ENABLE();
/*##-2- Configure peripheral GPIO ##########################################*/
/* Configure TIM2_Channel3 in output, push-pull & alternate function mode */
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_PULLUP;
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
GPIO_InitStruct.Alternate = GPIO_AF2_TIM2;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*##-3- Configure the DMA stream ###########################################*/
/* Set the parameters to be configured */
hdma_tim.Init.Request = DMA_REQUEST_8;
hdma_tim.Instance = DMA1_Channel2;
hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_tim.Init.MemInc = DMA_MINC_ENABLE;
hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdma_tim.Init.Mode = DMA_NORMAL;
hdma_tim.Init.Priority = DMA_PRIORITY_HIGH;
/* Link hdma_tim to hdma[TIM_DMA_ID_CC3] (channel3) */
__HAL_LINKDMA(htim, hdma[TIM_DMA_ID_UPDATE], hdma_tim);
/* Initialize TIMx DMA handle */
HAL_DMA_Init(htim->hdma[TIM_DMA_ID_UPDATE]);
/*##-4- Configure the NVIC for DMA #########################################*/
/* NVIC configuration for DMA transfer complete interrupt */
HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
}
//******************************************************************************
// board_adc_enable_clock
//
// Enable the clock for a specifc ADC module.
// Requires the caller previously invoked board_adc_get_status_block()
//
// Note that ADC_AUTO_MODULE = 0, so it is the first entry in the lookup table
//******************************************************************************
void board_adc_enable_clocks (int module_id)
{
// ON L4 / F7, default module must be ADC 3 !!!
if (module_id == 1)
__HAL_RCC_ADC1_CLK_ENABLE(); // Enable ADC Periph clock
else if (module_id == 2)
__HAL_RCC_ADC2_CLK_ENABLE();
else if (module_id == 3 || module_id == ADCMD)
__HAL_RCC_ADC3_CLK_ENABLE(); // F7 46G just supports 3 ADCs
// Enable the ADC module's associated DMA module's clocks
__HAL_RCC_DMA2_CLK_ENABLE(); // Enable DMA2 clock F4/F7
__DMA1_CLK_ENABLE(); // Enable F3_03/L0/F0 DMA clock - F0 has only
// 1 DMA unit, except F09x which has 2 and F3_34 has 3
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
__DMA2_CLK_ENABLE();
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 1, 0); /* SPI */
HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 1, 0); /* SPI */
HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 2, 0); /* I2C */
HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 3, 0); /* UART */
HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
}
void APP_ADC_Init(ADC_HandleTypeDef *hadc)
{
GPIO_InitTypeDef GPIO_InitStruct;
static DMA_HandleTypeDef DmaHandle;
/*##-1- Enable peripherals and GPIO Clocks #################################*/
/* Enable GPIO clock ****************************************/
__GPIOA_CLK_ENABLE();
/* ADC1 Periph clock enable */
__ADC1_CLK_ENABLE();
/* Enable DMA1 clock */
__DMA1_CLK_ENABLE();
/*##- 2- Configure peripheral GPIO #########################################*/
/* ADC3 Channel8 GPIO pin configuration */
GPIO_InitStruct.Pin = GPIO_PIN_0| GPIO_PIN_1;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/*##- 3- Configure DMA #####################################################*/
/*********************** Configure DMA parameters ***************************/
DmaHandle.Instance = DMA1_Channel1;
DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY;
DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE;
DmaHandle.Init.MemInc = DMA_MINC_ENABLE;
DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
DmaHandle.Init.Mode = DMA_CIRCULAR;
DmaHandle.Init.Priority = DMA_PRIORITY_MEDIUM;
DmaHandle.Init.Request = DMA_REQUEST_0;
/* Deinitialize & Initialize the DMA for new transfer */
HAL_DMA_DeInit(&DmaHandle);
HAL_DMA_Init(&DmaHandle);
/* Associate the DMA handle */
__HAL_LINKDMA(hadc, DMA_Handle, DmaHandle);
/* NVIC configuration for DMA Input data interrupt */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
}
/**
* @brief Configure the DMA controller according to the Stream parameters
* defined in main.h file
* @note This function is used to :
* -1- Enable DMA1 clock
* -2- Select the DMA functional Parameters
* -3- Select the DMA instance to be used for the transfer
* -4- Select Callbacks functions called after Transfer complete and
Transfer error interrupt detection
* -5- Initialize the DMA channel
* -6- Configure NVIC for DMA transfer complete/error interrupts
* -7- Start the DMA transfer using the interrupt mode
* @param None
* @retval None
*/
static void DMA_Config(void)
{
/*## -1- Enable DMA1 clock #################################################*/
__DMA1_CLK_ENABLE();
/*##-2- Select the DMA functional Parameters ###############################*/
DmaHandle.Init.Direction = DMA_MEMORY_TO_MEMORY; /* M2M transfer mode */
DmaHandle.Init.PeriphInc = DMA_PINC_ENABLE; /* Peripheral increment mode Enable */
DmaHandle.Init.MemInc = DMA_MINC_ENABLE; /* Memory increment mode Enable */
DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD; /* Peripheral data alignment : Word */
DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD; /* memory data alignment : Word */
DmaHandle.Init.Mode = DMA_NORMAL; /* Normal DMA mode */
DmaHandle.Init.Priority = DMA_PRIORITY_HIGH; /* priority level : high */
/*##-3- Select the DMA instance to be used for the transfer : DMA1_Channel1 #*/
DmaHandle.Instance = DMA_INSTANCE;
/*##-4- Select Callbacks functions called after Transfer complete and Transfer error */
DmaHandle.XferCpltCallback = TransferComplete;
DmaHandle.XferErrorCallback = TransferError;
/*##-5- Initialize the DMA channel ##########################################*/
if (HAL_DMA_Init(&DmaHandle) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-6- Configure NVIC for DMA transfer complete/error interrupts ##########*/
/* Set Interrupt Group Priority */
HAL_NVIC_SetPriority(DMA_INSTANCE_IRQ, 0, 0);
/* Enable the DMA STREAM global Interrupt */
HAL_NVIC_EnableIRQ(DMA_INSTANCE_IRQ);
/*##-7- Start the DMA transfer using the interrupt mode ####################*/
/* Configure the source, destination and buffer size DMA fields and Start DMA Stream transfer */
/* Enable All the DMA interrupts */
if (HAL_DMA_Start_IT(&DmaHandle, (uint32_t)&aSRC_Const_Buffer, (uint32_t)&aDST_Buffer, BUFFER_SIZE) != HAL_OK)
{
/* Transfer Error */
Error_Handler();
}
}
void dma_init(DMA_HandleTypeDef *dma, DMA_Stream_TypeDef *dma_stream, const DMA_InitTypeDef *dma_init, uint32_t dma_channel, uint32_t direction, void *data) {
int dma_id = get_dma_id(dma_stream);
//printf("dma_init(%p, %p(%d), 0x%x, 0x%x, %p)\n", dma, dma_stream, dma_id, (uint)dma_channel, (uint)direction, data);
// TODO possibly don't need to clear the entire structure
memset(dma, 0, sizeof(*dma));
// set global pointer for IRQ handler
dma_handle[dma_id] = dma;
// initialise parameters
dma->Instance = dma_stream;
dma->Init = *dma_init;
dma->Init.Direction = direction;
dma->Init.Channel = dma_channel;
// half of __HAL_LINKDMA(data, xxx, *dma)
// caller must implement other half by doing: data->xxx = dma
dma->Parent = data;
// if this stream was previously configured for this channel then we
// can skip most of the initialisation
if (dma_last_channel[dma_id] == dma_channel) {
goto same_channel;
}
dma_last_channel[dma_id] = dma_channel;
// enable clock for needed DMA peripheral
if (dma_id <= 7) {
__DMA1_CLK_ENABLE();
} else {
__DMA2_CLK_ENABLE();
}
// reset and configure DMA peripheral
HAL_DMA_DeInit(dma);
HAL_DMA_Init(dma);
HAL_NVIC_SetPriority(dma_irqn[dma_id], 6, 0);
same_channel:
HAL_NVIC_EnableIRQ(dma_irqn[dma_id]);
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
void Hardware_Init(void)
{
HAL_Init();
SystemClock_Config();
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
__GPIOC_CLK_ENABLE();
__GPIOD_CLK_ENABLE();
__GPIOE_CLK_ENABLE();
__GPIOF_CLK_ENABLE();
__GPIOG_CLK_ENABLE();
__DMA1_CLK_ENABLE(); // Для DAC1 (бикалка)
__TIM7_CLK_ENABLE(); // Для DAC1 (бикалка)
__DAC_CLK_ENABLE(); // Для бикалки
__PWR_CLK_ENABLE();
__SYSCFG_CLK_ENABLE();
HAL_NVIC_SetPriority(SysTick_IRQn, PRIORITY_SYS_TICK);
// Timer /////////////////////////////////////////////////////////////////
//RCC_PCLK1Config(RCC_HCLK_Div1);
// Таймер для мс
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, PRIORITY_TIMER_TIM6);
HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
Timer_Init();
Panel_Init();
FSMC_Init();
FSMC_SetMode(ModeFSMC_FPGA);
FDrive_Init();
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
/* DMA interrupt init for i2c 1*/
HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
/* DMA interrupt init for UART 2*/
HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);
/* DMA interrupt init for SPI 3 */
HAL_NVIC_SetPriority(DMA1_Stream2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream2_IRQn);
HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn);
}
void Hardware_Init()
{
HAL_Init();
SystemClock_Config();
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
__GPIOC_CLK_ENABLE();
__GPIOD_CLK_ENABLE();
__GPIOE_CLK_ENABLE();
__GPIOF_CLK_ENABLE();
__GPIOG_CLK_ENABLE();
__DMA1_CLK_ENABLE(); // Для DAC1 (бикалка)
__TIM6_CLK_ENABLE(); // Для отсчёта миллисекунд
__TIM2_CLK_ENABLE(); // Для тиков
__TIM7_CLK_ENABLE(); // Для DAC1 (бикалка)
__DAC_CLK_ENABLE(); // Для бикалки
__PWR_CLK_ENABLE();
__SYSCFG_CLK_ENABLE();
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
// Timer /////////////////////////////////////////////////////////////////
//RCC_PCLK1Config(RCC_HCLK_Div1);
// Таймер для мс
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 2, 0);
HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
if (HAL_TIM_Base_Init(&handleTIM6forTimer) != HAL_OK)
{
HARDWARE_ERROR
}
if (HAL_TIM_Base_Start_IT(&handleTIM6forTimer) != HAL_OK)
{
HARDWARE_ERROR
}
// Таймер для тиков
TIM_HandleTypeDef tim2handle =
{
TIM2,
{
0,
TIM_COUNTERMODE_UP,
0xffffffff,
TIM_CLOCKDIVISION_DIV1
}
};
if (HAL_TIM_Base_Init(&tim2handle) != HAL_OK)
{
HARDWARE_ERROR
}
if (HAL_TIM_Base_Start(&tim2handle) != HAL_OK)
{
HARDWARE_ERROR
}
Sound_Init();
#ifdef SPI_ENABLE
Panel_Init();
#endif
FSMC_Init();
ADC_Init();
FDrive_Init();
// Analog and DAC programmable SPI ////////////////////////////////////////
GPIO_InitTypeDef isGPIOG =
{
GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_5 | GPIO_PIN_7, // GPIO_PIN_1 - для работы с дисплеем
GPIO_MODE_OUTPUT_PP,
GPIO_NOPULL,
GPIO_SPEED_HIGH,
GPIO_AF0_MCO
};
HAL_GPIO_Init(GPIOG, &isGPIOG);
isGPIOG.Pin = GPIO_PIN_1;
isGPIOG.Mode = GPIO_MODE_OUTPUT_PP;
isGPIOG.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOG, &isGPIOG);
HAL_GPIO_WritePin(GPIOG, GPIO_PIN_1, GPIO_PIN_RESET); // PG1 - когда равен 1, чтение дисплея, в остальных случаях 0
RTC_Init();
}
///////////////////////////////////////////////////////////////////////////////
/// @brief Initializes all system components
void sysInitialize(void)
{
HAL_Init();
// system clock setup
halSystemClockConfig();
// GPIO Ports Clock Enable
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOH_CLK_ENABLE();
__DMA1_CLK_ENABLE();
__DMA2_CLK_ENABLE();
// Init drivers
halRTCInit();
sysHighresTimerInit();
drvServoInit();
drvPPMInit();
//imuInitialize();
// load configuration
cfgStorageInit();
cfgLoadDefaultConfiguration();
cfgLoadConfiguration();
// init uarts
halUARTInit();
// Init communication interfaces
comManagerInit();
//comUARTInit();
//comUDPInit();
//comHIDInit();
//cfgSaveConfiguration();
// init commuication
//comManagerInit();
//comUARTInit();
/*
uint8_t i;
// load configuration
cfgStorageInit();
cfgLoadDefaultConfiguration();
cfgLoadConfiguration();
// init uarts
for (i = 0; i < drvUART_MAX_COUNT; i++)
{
drvUARTInit(i);
}
// init commuication
comManagerInit();
comUDPInit();
comUARTInit();
//comESP8266Init();
//drvEthernetInit();
//comManagerInit();
//UARTInit(0);
//telemetryInit();
*/
}
void ws2811LedStripHardwareInit(void)
{
TimHandle.Instance = WS2811_TIMER;
TimHandle.Init.Prescaler = 1;
TimHandle.Init.Period = 135; // 800kHz
TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_PWM_Init(&TimHandle) != HAL_OK)
{
/* Initialization Error */
return;
}
static DMA_HandleTypeDef hdma_tim;
ws2811IO = IOGetByTag(IO_TAG(WS2811_PIN));
/* GPIOA Configuration: TIM5 Channel 1 as alternate function push-pull */
IOInit(ws2811IO, OWNER_LED_STRIP, RESOURCE_OUTPUT, 0);
IOConfigGPIOAF(ws2811IO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLUP), WS2811_TIMER_GPIO_AF);
__DMA1_CLK_ENABLE();
/* Set the parameters to be configured */
hdma_tim.Init.Channel = WS2811_DMA_CHANNEL;
hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE;
hdma_tim.Init.MemInc = DMA_MINC_ENABLE;
hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD ;
hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD ;
hdma_tim.Init.Mode = DMA_NORMAL;
hdma_tim.Init.Priority = DMA_PRIORITY_HIGH;
hdma_tim.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
hdma_tim.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
hdma_tim.Init.MemBurst = DMA_MBURST_SINGLE;
hdma_tim.Init.PeriphBurst = DMA_PBURST_SINGLE;
/* Set hdma_tim instance */
hdma_tim.Instance = WS2811_DMA_STREAM;
uint32_t channelAddress = 0;
switch (WS2811_TIMER_CHANNEL) {
case TIM_CHANNEL_1:
timDMASource = TIM_DMA_ID_CC1;
channelAddress = (uint32_t)(&WS2811_TIMER->CCR1);
break;
case TIM_CHANNEL_2:
timDMASource = TIM_DMA_ID_CC2;
channelAddress = (uint32_t)(&WS2811_TIMER->CCR2);
break;
case TIM_CHANNEL_3:
timDMASource = TIM_DMA_ID_CC3;
channelAddress = (uint32_t)(&WS2811_TIMER->CCR3);
break;
case TIM_CHANNEL_4:
timDMASource = TIM_DMA_ID_CC4;
channelAddress = (uint32_t)(&WS2811_TIMER->CCR4);
break;
}
/* Link hdma_tim to hdma[x] (channelx) */
__HAL_LINKDMA(&TimHandle, hdma[timDMASource], hdma_tim);
dmaSetHandler(WS2811_DMA_HANDLER_IDENTIFER, WS2811_DMA_IRQHandler, NVIC_PRIO_WS2811_DMA, timDMASource);
/* Initialize TIMx DMA handle */
if(HAL_DMA_Init(TimHandle.hdma[timDMASource]) != HAL_OK)
{
/* Initialization Error */
return;
}
TIM_OC_InitTypeDef TIM_OCInitStructure;
/* PWM1 Mode configuration: Channel1 */
TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
TIM_OCInitStructure.Pulse = 0;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;
TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
TIM_OCInitStructure.OCFastMode = TIM_OCFAST_DISABLE;
if(HAL_TIM_PWM_ConfigChannel(&TimHandle, &TIM_OCInitStructure, WS2811_TIMER_CHANNEL) != HAL_OK)
{
/* Configuration Error */
return;
}
const hsvColor_t hsv_white = { 0, 255, 255};
ws2811Initialised = true;
setStripColor(&hsv_white);
}
/* ADC init function */
void MX_ADC_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
/* Peripheral clock enable */
__ADC1_CLK_ENABLE();
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
/**ADC GPIO Configuration
PA0-WKUP ------> ADC_IN0
*/
GPIO_InitStruct.Pin = GPIO_PIN_0;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
/* Peripheral DMA init*/
DmaHandle.Instance = DMA1_Channel1;
DmaHandle.Init.Request = DMA_REQUEST_0;
DmaHandle.Init.Direction = DMA_PERIPH_TO_MEMORY;
DmaHandle.Init.PeriphInc = DMA_PINC_DISABLE;
DmaHandle.Init.MemInc = DMA_MINC_ENABLE;
DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
DmaHandle.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
DmaHandle.Init.Mode = DMA_CIRCULAR;
DmaHandle.Init.Priority = DMA_PRIORITY_MEDIUM;
HAL_DMA_DeInit(&DmaHandle);
HAL_DMA_Init(&DmaHandle);
__HAL_LINKDMA(&AdcHandle, DMA_Handle, DmaHandle);
/* DMA interrupt init */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
ADC_ChannelConfTypeDef sConfig;
ADC_AnalogWDGConfTypeDef AnalogWDGConfig;
/**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
*/
AdcHandle.Instance = ADC1;
AdcHandle.Init.OversamplingMode = DISABLE;
AdcHandle.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV1;
AdcHandle.Init.Resolution = ADC_RESOLUTION8b;
AdcHandle.Init.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
AdcHandle.Init.ScanDirection = ADC_SCAN_DIRECTION_UPWARD;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.ContinuousConvMode = ENABLE;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIG_EDGE_NONE;
AdcHandle.Init.DMAContinuousRequests = ENABLE;
AdcHandle.Init.EOCSelection = EOC_SINGLE_CONV;
AdcHandle.Init.Overrun = OVR_DATA_PRESERVED;
AdcHandle.Init.LowPowerAutoWait = DISABLE;
AdcHandle.Init.LowPowerFrequencyMode = DISABLE;
AdcHandle.Init.LowPowerAutoOff = DISABLE;
HAL_ADC_Init(&AdcHandle);
HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED);
sConfig.Channel = ADC_CHANNEL_0;
HAL_ADC_ConfigChannel(&AdcHandle, &sConfig);
/**Configure the analog watchdog
*/
AnalogWDGConfig.WatchdogMode = ADC_ANALOGWATCHDOG_SINGLE_REG;
AnalogWDGConfig.Channel = ADC_CHANNEL_0;
AnalogWDGConfig.ITMode = ENABLE;
AnalogWDGConfig.HighThreshold = 0;
AnalogWDGConfig.LowThreshold = 0;
HAL_ADC_AnalogWDGConfig(&AdcHandle, &AnalogWDGConfig);
HAL_ADC_Start_DMA(&AdcHandle, &resultDMA, DMA_BUFFER_SIZE);
}
void pwmDshotMotorHardwareConfig(const timerHardware_t *timerHardware, uint8_t motorIndex, motorPwmProtocolTypes_e pwmProtocolType, uint8_t output)
{
motorDmaOutput_t * const motor = &dmaMotors[motorIndex];
motor->timerHardware = timerHardware;
TIM_TypeDef *timer = timerHardware->tim;
const IO_t motorIO = IOGetByTag(timerHardware->tag);
const uint8_t timerIndex = getTimerIndex(timer);
IOInit(motorIO, OWNER_MOTOR, RESOURCE_INDEX(motorIndex));
IOConfigGPIOAF(motorIO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLUP), timerHardware->alternateFunction);
__DMA1_CLK_ENABLE();
RCC_ClockCmd(timerRCC(timer), ENABLE);
motor->TimHandle.Instance = timerHardware->tim;
motor->TimHandle.Init.Prescaler = (timerClock(timer) / getDshotHz(pwmProtocolType)) - 1;
motor->TimHandle.Init.Period = pwmProtocolType == PWM_TYPE_PROSHOT1000 ? MOTOR_NIBBLE_LENGTH_PROSHOT : MOTOR_BITLENGTH;
motor->TimHandle.Init.RepetitionCounter = 0;
motor->TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
motor->TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
motor->TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_PWM_Init(&motor->TimHandle) != HAL_OK) {
/* Initialization Error */
return;
}
motor->timerDmaSource = timerDmaSource(timerHardware->channel);
dmaMotorTimers[timerIndex].timerDmaSources |= motor->timerDmaSource;
/* Set the parameters to be configured */
motor->hdma_tim.Init.Channel = timerHardware->dmaChannel;
motor->hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH;
motor->hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE;
motor->hdma_tim.Init.MemInc = DMA_MINC_ENABLE;
motor->hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
motor->hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
motor->hdma_tim.Init.Mode = DMA_NORMAL;
motor->hdma_tim.Init.Priority = DMA_PRIORITY_HIGH;
motor->hdma_tim.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
motor->hdma_tim.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
motor->hdma_tim.Init.MemBurst = DMA_MBURST_SINGLE;
motor->hdma_tim.Init.PeriphBurst = DMA_PBURST_SINGLE;
/* Set hdma_tim instance */
if (timerHardware->dmaRef == NULL) {
/* Initialization Error */
return;
}
motor->hdma_tim.Instance = timerHardware->dmaRef;
/* Link hdma_tim to hdma[x] (channelx) */
__HAL_LINKDMA(&motor->TimHandle, hdma[motor->timerDmaSource], motor->hdma_tim);
dmaInit(timerHardware->dmaIrqHandler, OWNER_MOTOR, RESOURCE_INDEX(motorIndex));
dmaSetHandler(timerHardware->dmaIrqHandler, motor_DMA_IRQHandler, NVIC_BUILD_PRIORITY(1, 2), motorIndex);
/* Initialize TIMx DMA handle */
if (HAL_DMA_Init(motor->TimHandle.hdma[motor->timerDmaSource]) != HAL_OK) {
/* Initialization Error */
return;
}
TIM_OC_InitTypeDef TIM_OCInitStructure;
/* PWM1 Mode configuration: Channel1 */
TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
if (output & TIMER_OUTPUT_N_CHANNEL) {
TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;
TIM_OCInitStructure.OCPolarity = (output & TIMER_OUTPUT_INVERTED) ? TIM_OCPOLARITY_HIGH : TIM_OCPOLARITY_LOW;
TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
TIM_OCInitStructure.OCNPolarity = (output & TIMER_OUTPUT_INVERTED) ? TIM_OCNPOLARITY_HIGH : TIM_OCNPOLARITY_LOW;
} else {
TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_SET;
TIM_OCInitStructure.OCPolarity = (output & TIMER_OUTPUT_INVERTED) ? TIM_OCPOLARITY_LOW : TIM_OCPOLARITY_HIGH;
TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_SET;
TIM_OCInitStructure.OCNPolarity = (output & TIMER_OUTPUT_INVERTED) ? TIM_OCNPOLARITY_LOW : TIM_OCNPOLARITY_HIGH;
}
TIM_OCInitStructure.OCFastMode = TIM_OCFAST_DISABLE;
TIM_OCInitStructure.Pulse = 0;
if (HAL_TIM_PWM_ConfigChannel(&motor->TimHandle, &TIM_OCInitStructure, motor->timerHardware->channel) != HAL_OK) {
/* Configuration Error */
return;
}
}
void pwmDigitalMotorHardwareConfig(const timerHardware_t *timerHardware, uint8_t motorIndex, motorPwmProtocolTypes_e pwmProtocolType)
{
motorDmaOutput_t * const motor = &dmaMotors[motorIndex];
motor->timerHardware = timerHardware;
TIM_TypeDef *timer = timerHardware->tim;
const IO_t motorIO = IOGetByTag(timerHardware->tag);
const uint8_t timerIndex = getTimerIndex(timer);
const bool configureTimer = (timerIndex == dmaMotorTimerCount-1);
IOInit(motorIO, OWNER_MOTOR, RESOURCE_INDEX(motorIndex));
IOConfigGPIOAF(motorIO, IO_CONFIG(GPIO_MODE_AF_PP, GPIO_SPEED_FREQ_VERY_HIGH, GPIO_PULLUP), timerHardware->alternateFunction);
__DMA1_CLK_ENABLE();
if (configureTimer) {
RCC_ClockCmd(timerRCC(timer), ENABLE);
uint32_t hz;
switch (pwmProtocolType) {
case(PWM_TYPE_DSHOT600):
hz = MOTOR_DSHOT600_MHZ * 1000000;
break;
case(PWM_TYPE_DSHOT300):
hz = MOTOR_DSHOT300_MHZ * 1000000;
break;
default:
case(PWM_TYPE_DSHOT150):
hz = MOTOR_DSHOT150_MHZ * 1000000;
}
motor->TimHandle.Instance = timerHardware->tim;
motor->TimHandle.Init.Prescaler = (SystemCoreClock / timerClockDivisor(timer) / hz) - 1;;
motor->TimHandle.Init.Period = MOTOR_BITLENGTH;
motor->TimHandle.Init.RepetitionCounter = 0;
motor->TimHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
motor->TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
if(HAL_TIM_PWM_Init(&motor->TimHandle) != HAL_OK)
{
/* Initialization Error */
return;
}
}
else
{
motor->TimHandle = dmaMotors[timerIndex].TimHandle;
}
switch (timerHardware->channel) {
case TIM_CHANNEL_1:
motor->timerDmaSource = TIM_DMA_ID_CC1;
break;
case TIM_CHANNEL_2:
motor->timerDmaSource = TIM_DMA_ID_CC2;
break;
case TIM_CHANNEL_3:
motor->timerDmaSource = TIM_DMA_ID_CC3;
break;
case TIM_CHANNEL_4:
motor->timerDmaSource = TIM_DMA_ID_CC4;
break;
}
dmaMotorTimers[timerIndex].timerDmaSources |= motor->timerDmaSource;
/* Set the parameters to be configured */
motor->hdma_tim.Init.Channel = timerHardware->dmaChannel;
motor->hdma_tim.Init.Direction = DMA_MEMORY_TO_PERIPH;
motor->hdma_tim.Init.PeriphInc = DMA_PINC_DISABLE;
motor->hdma_tim.Init.MemInc = DMA_MINC_ENABLE;
motor->hdma_tim.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
motor->hdma_tim.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
motor->hdma_tim.Init.Mode = DMA_NORMAL;
motor->hdma_tim.Init.Priority = DMA_PRIORITY_HIGH;
motor->hdma_tim.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
motor->hdma_tim.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;
motor->hdma_tim.Init.MemBurst = DMA_MBURST_SINGLE;
motor->hdma_tim.Init.PeriphBurst = DMA_PBURST_SINGLE;
/* Set hdma_tim instance */
if(timerHardware->dmaStream == NULL)
{
/* Initialization Error */
return;
}
motor->hdma_tim.Instance = timerHardware->dmaStream;
/* Link hdma_tim to hdma[x] (channelx) */
__HAL_LINKDMA(&motor->TimHandle, hdma[motor->timerDmaSource], motor->hdma_tim);
dmaInit(timerHardware->dmaIrqHandler, OWNER_MOTOR, RESOURCE_INDEX(motorIndex));
dmaSetHandler(timerHardware->dmaIrqHandler, motor_DMA_IRQHandler, NVIC_BUILD_PRIORITY(1, 2), motorIndex);
/* Initialize TIMx DMA handle */
if(HAL_DMA_Init(motor->TimHandle.hdma[motor->timerDmaSource]) != HAL_OK)
{
/* Initialization Error */
return;
}
TIM_OC_InitTypeDef TIM_OCInitStructure;
/* PWM1 Mode configuration: Channel1 */
TIM_OCInitStructure.OCMode = TIM_OCMODE_PWM1;
TIM_OCInitStructure.OCPolarity = TIM_OCPOLARITY_HIGH;
TIM_OCInitStructure.OCIdleState = TIM_OCIDLESTATE_RESET;
TIM_OCInitStructure.OCNIdleState = TIM_OCNIDLESTATE_RESET;
TIM_OCInitStructure.OCFastMode = TIM_OCFAST_DISABLE;
TIM_OCInitStructure.Pulse = 0;
if(HAL_TIM_PWM_ConfigChannel(&motor->TimHandle, &TIM_OCInitStructure, motor->timerHardware->channel) != HAL_OK)
{
/* Configuration Error */
return;
}
}
/**
* @brief Initializes the SPI FLASH
* @param None
* @retval None
*/
ErrorStatus SPI_FLASH_Init()
{
/* Make sure we only initialize it once */
if (!prvInitialized)
{
/* Mutex semaphore for mutual exclusion to the SPI Flash device */
xSemaphore = xSemaphoreCreateMutex();
/* Init GPIO */
FLASH_GPIO_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Pin = FLASH_SCK_PIN | FLASH_MISO_PIN | FLASH_MOSI_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_AF_PP;
GPIO_InitStructure.Alternate = GPIO_AF5_SPI2;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Speed = GPIO_SPEED_HIGH;
HAL_GPIO_Init(FLASH_PORT, &GPIO_InitStructure);
GPIO_InitStructure.Pin = FLASH_CS_PIN;
GPIO_InitStructure.Mode = GPIO_MODE_OUTPUT_PP;
HAL_GPIO_Init(FLASH_PORT, &GPIO_InitStructure);
/* Deselect the FLASH */
prvSPI_FLASH_CS_HIGH();
/* DMA Init */
__DMA1_CLK_ENABLE();
HAL_DMA_Init(&DMA_HandleTx);
/* Associate the initialized DMA handle to the the SPI handle */
__HAL_LINKDMA(&SPI_Handle, hdmatx, DMA_HandleTx);
HAL_DMA_Init(&DMA_HandleRx);
/* Associate the initialized DMA handle to the the SPI handle */
__HAL_LINKDMA(&SPI_Handle, hdmarx, DMA_HandleRx);
/* NVIC configuration for DMA transfer complete interrupt (SPI2_TX) */
HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
/* NVIC configuration for DMA transfer complete interrupt (SPI2_RX) */
HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, configLIBRARY_LOWEST_INTERRUPT_PRIORITY-1, 0);
HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);
/* Init SPI */
FLASH_SPI_CLK_ENABLE();
HAL_SPI_Init(&SPI_Handle);
/* Read FLASH identification */
prvDeviceId = SPI_FLASH_ReadID();
if (prvDeviceId == SPI_FLASH_S25FL127SABMFI101_ID)
{
/* Select the FLASH */
prvSPI_FLASH_CS_LOW();
/* Send "Write Enable Status" instruction */
prvSPI_FLASH_SendReceiveByte(SPI_FLASH_CMD_EWSR);
/* Deselect the FLASH */
prvSPI_FLASH_CS_HIGH();
/* Select the FLASH */
prvSPI_FLASH_CS_LOW();
/* Send "Write Status Register" instruction and set all bits to 0 */
prvSPI_FLASH_SendReceiveByte(SPI_FLASH_CMD_WRSR);
prvSPI_FLASH_SendReceiveByte(0);
/* Deselect the FLASH */
prvSPI_FLASH_CS_HIGH();
prvInitialized = true;
return SUCCESS;
}
}
return ERROR;
}
/**
* Enable DMA controller clock
*/
void MX_DMA_Init(void)
{
/* DMA controller clock enable */
__DMA1_CLK_ENABLE();
}
//------------------------------------------------------------------------------------------------------------------------------------------------------
void Hardware_Init(void)
{
HAL_Init();
SystemClock_Config();
#ifndef _MS_VS
__GPIOA_CLK_ENABLE();
__GPIOB_CLK_ENABLE();
__GPIOC_CLK_ENABLE();
__GPIOD_CLK_ENABLE();
__GPIOE_CLK_ENABLE();
__GPIOF_CLK_ENABLE();
__GPIOG_CLK_ENABLE();
__DMA1_CLK_ENABLE(); // Для DAC1 (бикалка)
__TIM7_CLK_ENABLE(); // Для DAC1 (бикалка)
__DAC_CLK_ENABLE(); // Для бикалки
__PWR_CLK_ENABLE();
__SYSCFG_CLK_ENABLE();
#endif
HAL_NVIC_SetPriority(SysTick_IRQn, PRIORITY_SYS_TICK);
// Timer /////////////////////////////////////////////////////////////////
//RCC_PCLK1Config(RCC_HCLK_Div1);
// Таймер для мс
HAL_NVIC_SetPriority(TIM6_DAC_IRQn, PRIORITY_TIMER_TIM6);
HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);
Timer_Init();
Sound_Init();
Panel_Init();
FSMC_Init();
FSMC_SetMode(ModeFSMC_FPGA);
RAM_Init();
FDrive_Init();
// Analog and DAC programmable SPI ////////////////////////////////////////
GPIO_InitTypeDef isGPIO =
{
GPIO_PIN_10 | GPIO_PIN_12, // SPI SCLK, DATA
GPIO_MODE_OUTPUT_PP,
GPIO_NOPULL,
GPIO_SPEED_HIGH,
GPIO_AF0_MCO
};
HAL_GPIO_Init(GPIOC, &isGPIO);
isGPIO.Pin = GPIO_PIN_3 | GPIO_PIN_6; // SPI select1, select2
HAL_GPIO_Init(GPIOD, &isGPIO);
isGPIO.Pin = GPIO_PIN_10 | GPIO_PIN_15; // SPI select3, select4
HAL_GPIO_Init(GPIOG, &isGPIO);
RTC_Init();
}
mp_obj_t pyb_dac_write_timed(mp_uint_t n_args, const mp_obj_t *args, mp_map_t *kw_args) {
pyb_dac_obj_t *self = args[0];
// parse args
mp_arg_val_t vals[PYB_DAC_WRITE_TIMED_NUM_ARGS];
mp_arg_parse_all(n_args - 1, args + 1, kw_args, PYB_DAC_WRITE_TIMED_NUM_ARGS, pyb_dac_write_timed_args, vals);
// get the data to write
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(vals[0].u_obj, &bufinfo, MP_BUFFER_READ);
// set TIM6 to trigger the DAC at the given frequency
TIM6_Config(vals[1].u_int);
__DMA1_CLK_ENABLE();
/*
DMA_Cmd(self->dma_stream, DISABLE);
while (DMA_GetCmdStatus(self->dma_stream) != DISABLE) {
}
DAC_Cmd(self->dac_channel, DISABLE);
*/
/*
// DAC channel configuration
DAC_InitTypeDef DAC_InitStructure;
DAC_InitStructure.DAC_Trigger = DAC_Trigger_T7_TRGO;
DAC_InitStructure.DAC_WaveGeneration = DAC_WaveGeneration_None;
DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_TriangleAmplitude_1; // unused, but need to set it to a valid value
DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Enable;
DAC_Init(self->dac_channel, &DAC_InitStructure);
*/
// DMA1_Stream[67] channel7 configuration
DMA_HandleTypeDef DMA_Handle;
DMA_Handle.Instance = self->dma_stream;
// Need to deinit DMA first
DMA_Handle.State = HAL_DMA_STATE_READY;
HAL_DMA_DeInit(&DMA_Handle);
DMA_Handle.Init.Channel = DMA_CHANNEL_7;
DMA_Handle.Init.Direction = DMA_MEMORY_TO_PERIPH;
DMA_Handle.Init.PeriphInc = DMA_PINC_DISABLE;
DMA_Handle.Init.MemInc = DMA_MINC_ENABLE;
DMA_Handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
DMA_Handle.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
DMA_Handle.Init.Mode = vals[2].u_int;
DMA_Handle.Init.Priority = DMA_PRIORITY_HIGH;
DMA_Handle.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
DMA_Handle.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_HALFFULL;
DMA_Handle.Init.MemBurst = DMA_MBURST_SINGLE;
DMA_Handle.Init.PeriphBurst = DMA_PBURST_SINGLE;
HAL_DMA_Init(&DMA_Handle);
if (self->dac_channel == DAC_CHANNEL_1) {
__HAL_LINKDMA(&DAC_Handle, DMA_Handle1, DMA_Handle);
} else {
__HAL_LINKDMA(&DAC_Handle, DMA_Handle2, DMA_Handle);
}
DAC_Handle.Instance = DAC;
DAC_Handle.State = HAL_DAC_STATE_RESET;
HAL_DAC_Init(&DAC_Handle);
if (self->state != 3) {
DAC_ChannelConfTypeDef config;
config.DAC_Trigger = DAC_TRIGGER_T6_TRGO;
config.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
HAL_DAC_ConfigChannel(&DAC_Handle, &config, self->dac_channel);
self->state = 3;
}
HAL_DAC_Start_DMA(&DAC_Handle, self->dac_channel, (uint32_t*)bufinfo.buf, bufinfo.len, DAC_ALIGN_8B_R);
/*
// enable DMA stream
DMA_Cmd(self->dma_stream, ENABLE);
while (DMA_GetCmdStatus(self->dma_stream) == DISABLE) {
}
// enable DAC channel
DAC_Cmd(self->dac_channel, ENABLE);
// enable DMA for DAC channel
DAC_DMACmd(self->dac_channel, ENABLE);
*/
//printf("DMA: %p %lu\n", bufinfo.buf, bufinfo.len);
return mp_const_none;
}
void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp)
{
static DMA_HandleTypeDef hdmaIn;
static DMA_HandleTypeDef hdmaOut;
/* Enable CRYP clock */
__CRYP_CLK_ENABLE();
/* Force the CRYP Periheral Clock Reset */
__CRYP_FORCE_RESET();
/* Release the CRYP Periheral Clock Reset */
__CRYP_RELEASE_RESET();
/* Enable and set CRYP Interrupt to the highest priority */
HAL_NVIC_SetPriority(AES_RNG_LPUART1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(AES_RNG_LPUART1_IRQn);
/* Enable DMA1 clocks */
__DMA1_CLK_ENABLE();
__DMA1_FORCE_RESET();
__DMA1_RELEASE_RESET();
/***************** Configure common DMA In parameters ***********************/
hdmaIn.Instance = DMA1_Channel1;
hdmaIn.Init.Direction = DMA_MEMORY_TO_PERIPH;
hdmaIn.Init.PeriphInc = DMA_PINC_DISABLE;
hdmaIn.Init.MemInc = DMA_MINC_ENABLE;
hdmaIn.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdmaIn.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdmaIn.Init.Mode = DMA_NORMAL;
hdmaIn.Init.Priority = DMA_PRIORITY_MEDIUM;
hdmaIn.Init.Request = DMA_REQUEST_11;
/* Associate the DMA handle */
__HAL_LINKDMA(hcryp, hdmain, hdmaIn);
/* Deinitialize the Stream for new transfer */
HAL_DMA_DeInit(hcryp->hdmain);
/* Configure the DMA Stream */
HAL_DMA_Init(hcryp->hdmain);
/* NVIC configuration for DMA Input data interrupt */
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 1, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
/***************** Configure common DMA Out parameters **********************/
hdmaOut.Instance = DMA1_Channel3;
hdmaOut.Init.Direction = DMA_PERIPH_TO_MEMORY;
hdmaOut.Init.PeriphInc = DMA_PINC_DISABLE;
hdmaOut.Init.MemInc = DMA_MINC_ENABLE;
hdmaOut.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
hdmaOut.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
hdmaOut.Init.Mode = DMA_NORMAL;
hdmaOut.Init.Priority = DMA_PRIORITY_VERY_HIGH;
hdmaOut.Init.Request = DMA_REQUEST_11;
/* Associate the DMA handle */
__HAL_LINKDMA(hcryp, hdmaout, hdmaOut);
/* Deinitialize the Stream for new processing */
HAL_DMA_DeInit(&hdmaOut);
/* Configure the DMA Stream */
HAL_DMA_Init(&hdmaOut);
/* NVIC configuration for DMA output data interrupt */
/* Already configured */
HAL_NVIC_SetPriority(DMA1_Channel2_3_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_3_IRQn);
}