自学教程：C++ HAL_NVIC_SetPriority函数代码示例

/**  * @brief SPI 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   *           - NVIC configuration for DMA interrupt request enable  * @param hspi: SPI handle pointer  * @retval None  */void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi){GPIO_InitTypeDef  GPIO_InitStruct;	  if (hspi->Instance == SPIx)  {    /*##-1- Enable peripherals and GPIO Clocks #################################*/    /* Enable GPIO TX/RX clock */    SPIx_SCK_GPIO_CLK_ENABLE();    SPIx_MISO_GPIO_CLK_ENABLE();    SPIx_MOSI_GPIO_CLK_ENABLE();    /* Enable SPI2 clock */    SPIx_CLK_ENABLE();    /* Enable DMA clock */    DMAx_CLK_ENABLE();    /*##-2- Configure peripheral GPIO ##########################################*/      /* SPI SCK GPIO pin configuration  */    GPIO_InitStruct.Pin       = SPIx_SCK_PIN;    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull      = GPIO_PULLDOWN;    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);    /* SPI MISO GPIO pin configuration  */    GPIO_InitStruct.Pin = SPIx_MISO_PIN;    HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);    /* SPI MOSI GPIO pin configuration  */    GPIO_InitStruct.Pin = SPIx_MOSI_PIN;    HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);    /*##-3- Configure the DMA ##################################################*/    /* Configure the DMA handler for Transmission process */    hdma_tx.Instance                 = SPIx_TX_DMA_CHANNEL;    hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;    hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;    hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;    hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;    hdma_tx.Init.Mode                = DMA_NORMAL;    hdma_tx.Init.Priority            = DMA_PRIORITY_LOW;    HAL_DMA_Init(&hdma_tx);    /* Associate the initialized DMA handle to the the SPI handle */    __HAL_LINKDMA(hspi, hdmatx, hdma_tx);    /* Configure the DMA handler for Transmission process */    hdma_rx.Instance                 = SPIx_RX_DMA_CHANNEL;    hdma_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;    hdma_rx.Init.PeriphInc           = DMA_PINC_DISABLE;    hdma_rx.Init.MemInc              = DMA_MINC_ENABLE;    hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;    hdma_rx.Init.Mode                = DMA_NORMAL;    hdma_rx.Init.Priority            = DMA_PRIORITY_HIGH;    HAL_DMA_Init(&hdma_rx);    /* Associate the initialized DMA handle to the the SPI handle */    __HAL_LINKDMA(hspi, hdmarx, hdma_rx);        /*##-4- Configure the NVIC for DMA #########################################*/     /* NVIC configuration for DMA transfer complete interrupt (SPI2_TX) */    HAL_NVIC_SetPriority(SPIx_DMA_TX_IRQn, 1, 1);    HAL_NVIC_EnableIRQ(SPIx_DMA_TX_IRQn);        /* NVIC configuration for DMA transfer complete interrupt (SPI2_RX) */    HAL_NVIC_SetPriority(SPIx_DMA_RX_IRQn, 1, 0);    HAL_NVIC_EnableIRQ(SPIx_DMA_RX_IRQn);  }}

void pendsv_init(void) {    // set PendSV interrupt at lowest priority    HAL_NVIC_SetPriority(PendSV_IRQn, 0xf, 0xf);}

/**  * @brief SPI 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   *           - NVIC configuration for DMA interrupt request enable  * @param hspi: SPI handle pointer  * @retval None  */void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi){  static DMA_HandleTypeDef hdma_tx;  static DMA_HandleTypeDef hdma_rx;    GPIO_InitTypeDef  GPIO_InitStruct;    /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO TX/RX clock */  SPIx_SCK_GPIO_CLK_ENABLE();  SPIx_MISO_GPIO_CLK_ENABLE();  SPIx_MOSI_GPIO_CLK_ENABLE();  /* Enable SPI3 clock */  SPIx_CLK_ENABLE();   /* Enable DMA1 clock */  DMAx_CLK_ENABLE();       /*##-2- Configure peripheral GPIO ##########################################*/    /* SPI SCK GPIO pin configuration  */  GPIO_InitStruct.Pin       = SPIx_SCK_PIN;  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull      = GPIO_PULLUP;  GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;  GPIO_InitStruct.Alternate = SPIx_SCK_AF;    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);      /* SPI MISO GPIO pin configuration  */  GPIO_InitStruct.Pin = SPIx_MISO_PIN;  GPIO_InitStruct.Alternate = SPIx_MISO_AF;    HAL_GPIO_Init(SPIx_MISO_GPIO_PORT, &GPIO_InitStruct);    /* SPI MOSI GPIO pin configuration  */  GPIO_InitStruct.Pin = SPIx_MOSI_PIN;  GPIO_InitStruct.Alternate = SPIx_MOSI_AF;      HAL_GPIO_Init(SPIx_MOSI_GPIO_PORT, &GPIO_InitStruct);      /*##-3- Configure the DMA streams ##########################################*/  /* Configure the DMA handler for Transmission process */  hdma_tx.Instance                 = SPIx_TX_DMA_STREAM;    hdma_tx.Init.Channel             = SPIx_TX_DMA_CHANNEL;  hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;  hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;  hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma_tx.Init.Mode                = DMA_NORMAL;  hdma_tx.Init.Priority            = DMA_PRIORITY_LOW;  hdma_tx.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;           hdma_tx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;  hdma_tx.Init.MemBurst            = DMA_MBURST_INC4;  hdma_tx.Init.PeriphBurst         = DMA_PBURST_INC4;    HAL_DMA_Init(&hdma_tx);       /* Associate the initialized DMA handle to the the SPI handle */  __HAL_LINKDMA(hspi, hdmatx, hdma_tx);      /* Configure the DMA handler for Transmission process */  hdma_rx.Instance                 = SPIx_RX_DMA_STREAM;    hdma_rx.Init.Channel             = SPIx_RX_DMA_CHANNEL;  hdma_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;  hdma_rx.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_rx.Init.MemInc              = DMA_MINC_ENABLE;  hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma_rx.Init.Mode                = DMA_NORMAL;  hdma_rx.Init.Priority            = DMA_PRIORITY_HIGH;  hdma_rx.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;           hdma_rx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;  hdma_rx.Init.MemBurst            = DMA_MBURST_INC4;  hdma_rx.Init.PeriphBurst         = DMA_PBURST_INC4;   HAL_DMA_Init(&hdma_rx);      /* Associate the initialized DMA handle to the the SPI handle */  __HAL_LINKDMA(hspi, hdmarx, hdma_rx);      /*##-4- Configure the NVIC for DMA #########################################*/   /* NVIC configuration for DMA transfer complete interrupt (SPI3_TX) */  HAL_NVIC_SetPriority(SPIx_DMA_TX_IRQn, 0, 1);  HAL_NVIC_EnableIRQ(SPIx_DMA_TX_IRQn);      /* NVIC configuration for DMA transfer complete interrupt (SPI3_RX) */  HAL_NVIC_SetPriority(SPIx_DMA_RX_IRQn, 0, 0);     HAL_NVIC_EnableIRQ(SPIx_DMA_RX_IRQn);//.........这里部分代码省略.........

/**  * @brief  Initializes I2C MSP.  * @param  None  * @retval None  */static void I2Sx_MspInit(void){   static DMA_HandleTypeDef hdma_i2sTx;  GPIO_InitTypeDef  GPIO_InitStruct;    I2S_HandleTypeDef *hi2s = &haudio_i2s;    /* Enable I2S clock */  AUDIO_I2Sx_CLK_ENABLE();    /* Enable SCK, SD and WS GPIO clock */  AUDIO_I2Sx_SCK_SD_WS_CLK_ENABLE();    /* CODEC_I2S pins configuration: WS, SCK and SD pins */  GPIO_InitStruct.Pin = AUDIO_I2Sx_SCK_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull = GPIO_NOPULL;  GPIO_InitStruct.Speed = GPIO_SPEED_FAST;  GPIO_InitStruct.Alternate = AUDIO_I2Sx_SCK_SD_WS_AF;  HAL_GPIO_Init(AUDIO_I2Sx_SCK_SD_WS_GPIO_PORT, &GPIO_InitStruct);    GPIO_InitStruct.Pin = AUDIO_I2Sx_SD_PIN;  HAL_GPIO_Init(AUDIO_I2Sx_SCK_SD_WS_GPIO_PORT, &GPIO_InitStruct);     GPIO_InitStruct.Pin = AUDIO_I2Sx_WS_PIN;  HAL_GPIO_Init(AUDIO_I2Sx_SCK_SD_WS_GPIO_PORT, &GPIO_InitStruct);     /* Enable MCK GPIO clock */  AUDIO_I2Sx_MCK_CLK_ENABLE();    /* CODEC_I2S pins configuration: MCK pin */  GPIO_InitStruct.Pin = AUDIO_I2Sx_MCK_PIN;  HAL_GPIO_Init(AUDIO_I2Sx_MCK_GPIO_PORT, &GPIO_InitStruct);     /* Enable the DMA clock */  AUDIO_I2Sx_DMAx_CLK_ENABLE();      if(hi2s->Instance == AUDIO_I2Sx)  {    /* Configure the hdma_i2sTx handle parameters */       hdma_i2sTx.Init.Channel             = AUDIO_I2Sx_DMAx_CHANNEL;    hdma_i2sTx.Init.Direction           = DMA_MEMORY_TO_PERIPH;    hdma_i2sTx.Init.PeriphInc           = DMA_PINC_DISABLE;    hdma_i2sTx.Init.MemInc              = DMA_MINC_ENABLE;    hdma_i2sTx.Init.PeriphDataAlignment = AUDIO_I2Sx_DMAx_PERIPH_DATA_SIZE;    hdma_i2sTx.Init.MemDataAlignment    = AUDIO_I2Sx_DMAx_MEM_DATA_SIZE;    hdma_i2sTx.Init.Mode                = DMA_NORMAL;    hdma_i2sTx.Init.Priority            = DMA_PRIORITY_HIGH;    hdma_i2sTx.Init.FIFOMode            = DMA_FIFOMODE_ENABLE;             hdma_i2sTx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;    hdma_i2sTx.Init.MemBurst            = DMA_MBURST_SINGLE;    hdma_i2sTx.Init.PeriphBurst         = DMA_PBURST_SINGLE;         hdma_i2sTx.Instance = AUDIO_I2Sx_DMAx_STREAM;        /* Associate the DMA handle */    __HAL_LINKDMA(hi2s, hdmatx, hdma_i2sTx);        /* Deinitialize the Stream for new transfer */    HAL_DMA_DeInit(&hdma_i2sTx);        /* Configure the DMA Stream */    HAL_DMA_Init(&hdma_i2sTx);        }    /* I2S DMA IRQ Channel configuration */  HAL_NVIC_SetPriority(AUDIO_I2Sx_DMAx_IRQ, AUDIO_IRQ_PREPRIO, 0);  HAL_NVIC_EnableIRQ(AUDIO_I2Sx_DMAx_IRQ); }

/**  * @brief  Initializes the PCD MSP.  * @param  hpcd: PCD handle  * @retval None  */void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd){  GPIO_InitTypeDef  GPIO_InitStruct;	if( hpcd->Instance == USB_OTG_FS )	{		/* Configure USB FS GPIOs */		__HAL_RCC_GPIOA_CLK_ENABLE();		/* Configure DM DP Pins */		GPIO_InitStruct.Pin         =   (GPIO_PIN_11 | GPIO_PIN_12);		GPIO_InitStruct.Mode        =   GPIO_MODE_AF_PP;		GPIO_InitStruct.Pull        =   GPIO_NOPULL;		GPIO_InitStruct.Speed       =   GPIO_SPEED_HIGH;		GPIO_InitStruct.Alternate   =   GPIO_AF10_OTG_FS;		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);		/* Configure VBUS Pin *//*		GPIO_InitStruct.Pin = GPIO_PIN_9;		GPIO_InitStruct.Mode = GPIO_MODE_INPUT;		GPIO_InitStruct.Pull = GPIO_NOPULL;		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);*/		/* Configure ID pin *//*		GPIO_InitStruct.Pin = GPIO_PIN_10;		GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;		GPIO_InitStruct.Pull = GPIO_PULLUP;		GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;		HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);*/                __HAL_RCC_USB_OTG_FS_CLK_ENABLE();                //HAL_NVIC_SetPriority(OTG_FS_IRQn, 6, 0);                HAL_NVIC_SetPriority( OTG_FS_IRQn, BSP_NVIC_PRIO_USB_FS, 0 );                HAL_NVIC_EnableIRQ( OTG_FS_IRQn );        }        else if( hpcd->Instance == USB_OTG_HS )        {                __HAL_RCC_GPIOA_CLK_ENABLE();                __HAL_RCC_GPIOB_CLK_ENABLE();                __HAL_RCC_GPIOC_CLK_ENABLE();                /* CLK */                GPIO_InitStruct.Pin = GPIO_PIN_5;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);                /* D0 */                GPIO_InitStruct.Pin = GPIO_PIN_3;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);                /* D1 D2 D3 D4 D5 D6 D7 */                GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |/                                        GPIO_PIN_10 | GPIO_PIN_2 | GPIO_PIN_12 | GPIO_PIN_13;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);                /* STP */                GPIO_InitStruct.Pin = GPIO_PIN_0;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);                /* NXT */                GPIO_InitStruct.Pin = GPIO_PIN_3;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);                /* DIR */                GPIO_InitStruct.Pin = GPIO_PIN_2;                GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;                GPIO_InitStruct.Pull = GPIO_NOPULL;                GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;                HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);                __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();                __HAL_RCC_USB_OTG_HS_CLK_ENABLE();                HAL_NVIC_SetPriority(OTG_HS_IRQn, 6, 0);                HAL_NVIC_EnableIRQ(OTG_HS_IRQn);//.........这里部分代码省略.........

/**  * @brief  Initializes the HCD MSP.  * @param  hhcd: HCD handle  * @retval None  */void HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd){  GPIO_InitTypeDef  GPIO_InitStruct;    if(hhcd->Instance == USB_OTG_FS)  {    /* Configure USB FS GPIOs */    __GPIOA_CLK_ENABLE();    __GPIOH_CLK_ENABLE();        GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         GPIO_InitStruct.Pin = GPIO_PIN_10;    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;    GPIO_InitStruct.Pull = GPIO_PULLUP;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);         /* Enable USB FS Clocks */     __USB_OTG_FS_CLK_ENABLE();        /* Set USBFS Interrupt to the lowest priority */    HAL_NVIC_SetPriority(OTG_FS_IRQn, 5, 0);        /* Enable USBFS Interrupt */    HAL_NVIC_EnableIRQ(OTG_FS_IRQn);  }     else if(hhcd->Instance == USB_OTG_HS)  {    /* Configure USB HS GPIOs */    __GPIOA_CLK_ENABLE();    __GPIOB_CLK_ENABLE();    __GPIOC_CLK_ENABLE();    __GPIOH_CLK_ENABLE();            __GPIOI_CLK_ENABLE();        /* CLK */    GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* D0 */    GPIO_InitStruct.Pin = GPIO_PIN_3;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* D1 D2 D3 D4 D5 D6 D7 */    GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |/                          GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);         /* STP */        GPIO_InitStruct.Pin = GPIO_PIN_0;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);         /* NXT */    GPIO_InitStruct.Pin = GPIO_PIN_4;    HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);           /* DIR */    GPIO_InitStruct.Pin = GPIO_PIN_11;    HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);             /* Enable USB HS Clocks */     __USB_OTG_HS_CLK_ENABLE();    __USB_OTG_HS_ULPI_CLK_ENABLE();        /* Set USBHS Interrupt to the lowest priority */    HAL_NVIC_SetPriority(OTG_HS_IRQn, 5, 0);        /* Enable USBHS Interrupt */    HAL_NVIC_EnableIRQ(OTG_HS_IRQn);  }   }

/**  * @brief  Initializes SDRAM MSP.  * @param  hsdram: SDRAM handle  * @param  Params  * @retval None  */static void SDRAM_MspInit(SDRAM_HandleTypeDef  *hsdram, void *Params){    static DMA_HandleTypeDef dma_handle;    GPIO_InitTypeDef gpio_init_structure;    /* Enable FMC clock */    __HAL_RCC_FMC_CLK_ENABLE();    /* Enable chosen DMAx clock */    SDRAM_DMA_CLK_ENABLE();    /* Enable GPIOs clock */    __HAL_RCC_GPIOC_CLK_ENABLE();    __HAL_RCC_GPIOD_CLK_ENABLE();    __HAL_RCC_GPIOE_CLK_ENABLE();    __HAL_RCC_GPIOF_CLK_ENABLE();    __HAL_RCC_GPIOG_CLK_ENABLE();    __HAL_RCC_GPIOH_CLK_ENABLE();    /* Common GPIO configuration */    gpio_init_structure.Mode      = GPIO_MODE_AF_PP;    gpio_init_structure.Pull      = GPIO_PULLUP;    gpio_init_structure.Speed     = GPIO_SPEED_FAST;    gpio_init_structure.Alternate = GPIO_AF12_FMC;    /* GPIOC configuration */    gpio_init_structure.Pin   = GPIO_PIN_3;    HAL_GPIO_Init(GPIOC, &gpio_init_structure);    /* GPIOD configuration */    gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3 | GPIO_PIN_8 | GPIO_PIN_9 |                                GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15;    HAL_GPIO_Init(GPIOD, &gpio_init_structure);    /* GPIOE configuration */    gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | 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;    HAL_GPIO_Init(GPIOE, &gpio_init_structure);    /* GPIOF configuration */    gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |/                                GPIO_PIN_5 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 |/                                GPIO_PIN_15;    HAL_GPIO_Init(GPIOF, &gpio_init_structure);    /* GPIOG configuration */    gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4| GPIO_PIN_5 | GPIO_PIN_8 |/                                GPIO_PIN_15;    HAL_GPIO_Init(GPIOG, &gpio_init_structure);    /* GPIOH configuration */    gpio_init_structure.Pin   = GPIO_PIN_3 | GPIO_PIN_5;    HAL_GPIO_Init(GPIOH, &gpio_init_structure);    /* Configure common DMA parameters */    dma_handle.Init.Channel             = SDRAM_DMA_CHANNEL;    dma_handle.Init.Direction           = DMA_MEMORY_TO_MEMORY;    dma_handle.Init.PeriphInc           = DMA_PINC_ENABLE;    dma_handle.Init.MemInc              = DMA_MINC_ENABLE;    dma_handle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;    dma_handle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;    dma_handle.Init.Mode                = DMA_NORMAL;    dma_handle.Init.Priority            = DMA_PRIORITY_HIGH;    dma_handle.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;    dma_handle.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;    dma_handle.Init.MemBurst            = DMA_MBURST_SINGLE;    dma_handle.Init.PeriphBurst         = DMA_PBURST_SINGLE;    dma_handle.Instance = SDRAM_DMA_STREAM;    /* Associate the DMA handle */    __HAL_LINKDMA(hsdram, hdma, dma_handle);    /* Deinitialize the stream for new transfer */    HAL_DMA_DeInit(&dma_handle);    /* Configure the DMA stream */    HAL_DMA_Init(&dma_handle);    /* NVIC configuration for DMA transfer complete interrupt */    HAL_NVIC_SetPriority(SDRAM_DMA_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(SDRAM_DMA_IRQn);}

/**  * @brief UART 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  *           - NVIC configuration for DMA interrupt request enable  * @param huart: UART handle pointer  * @retval None  */void HAL_UART_MspInit(UART_HandleTypeDef *huart){  static DMA_HandleTypeDef hdma_tx;  GPIO_InitTypeDef  GPIO_InitStruct;  /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO clock */  USARTx_TX_GPIO_CLK_ENABLE();  USARTx_RX_GPIO_CLK_ENABLE();  /* Enable USARTx clock */  USARTx_CLK_ENABLE();  /* Enable DMA clock */  DMAx_CLK_ENABLE();  /*##-2- Configure peripheral GPIO ##########################################*/  /* UART TX GPIO pin configuration  */  GPIO_InitStruct.Pin       = USARTx_TX_PIN;  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull      = GPIO_PULLUP;  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;  HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);  /* UART RX GPIO pin configuration  */  GPIO_InitStruct.Pin = USARTx_RX_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;  HAL_GPIO_Init(USARTx_RX_GPIO_PORT, &GPIO_InitStruct);    /*##-3- Configure the NVIC for UART ########################################*/     HAL_NVIC_SetPriority(USARTx_IRQn, 4, 0);  HAL_NVIC_EnableIRQ(USARTx_IRQn);  /*##-4- Configure the DMA channels ##########################################*/  /* Configure the DMA handler for Transmission process */  hdma_tx.Instance                 = USARTx_TX_DMA_STREAM;  hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;  hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;  hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma_tx.Init.Mode                = DMA_NORMAL;  hdma_tx.Init.Priority            = DMA_PRIORITY_LOW;  HAL_DMA_Init(&hdma_tx);    /* Associate the initialized DMA handle to the UART handle */  __HAL_LINKDMA(huart, hdmatx, hdma_tx);    /*##-5- Configure the NVIC for DMA #########################################*/  /* NVIC configuration for DMA transfer complete interrupt (USARTx_TX) */  HAL_NVIC_SetPriority(USARTx_DMA_TX_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(USARTx_DMA_TX_IRQn);    /*##-6- Enable TIM peripherals Clock #######################################*/  TIMx_CLK_ENABLE();    /*##-7- Configure the NVIC for TIMx ########################################*/  /* Set Interrupt Group Priority */   HAL_NVIC_SetPriority(TIMx_IRQn, 5, 0);    /* Enable the TIMx global Interrupt */  HAL_NVIC_EnableIRQ(TIMx_IRQn);}

/**   * 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);}

//.........这里部分代码省略.........#if defined(SOC_SERIES_STM32F0) || defined(SOC_SERIES_STM32G0)    SPI_APB_CLOCK = HAL_RCC_GetPCLK1Freq();#else    SPI_APB_CLOCK = HAL_RCC_GetPCLK2Freq();#endif    if (cfg->max_hz >= SPI_APB_CLOCK / 2)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 4)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 8)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 16)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 32)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 64)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;    }    else if (cfg->max_hz >= SPI_APB_CLOCK / 128)    {        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;    }    else    {        /*  min prescaler 256 */        spi_handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;    }    LOG_D("sys freq: %d, pclk2 freq: %d, SPI limiting freq: %d, BaudRatePrescaler: %d",          HAL_RCC_GetSysClockFreq(),          SPI_APB_CLOCK,          cfg->max_hz,          spi_handle->Init.BaudRatePrescaler);    if (cfg->mode & RT_SPI_MSB)    {        spi_handle->Init.FirstBit = SPI_FIRSTBIT_MSB;    }    else    {        spi_handle->Init.FirstBit = SPI_FIRSTBIT_LSB;    }    spi_handle->Init.TIMode = SPI_TIMODE_DISABLE;    spi_handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;    spi_handle->State = HAL_SPI_STATE_RESET;#if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32G0)    spi_handle->Init.NSSPMode          = SPI_NSS_PULSE_DISABLE;#endif    if (HAL_SPI_Init(spi_handle) != HAL_OK)    {        return RT_EIO;    }#if defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32F0) /        || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32G0)    SET_BIT(spi_handle->Instance->CR2, SPI_RXFIFO_THRESHOLD_HF);#endif    /* DMA configuration */    if (spi_drv->spi_dma_flag & SPI_USING_RX_DMA_FLAG)    {        HAL_DMA_Init(&spi_drv->dma.handle_rx);        __HAL_LINKDMA(&spi_drv->handle, hdmarx, spi_drv->dma.handle_rx);        /* NVIC configuration for DMA transfer complete interrupt */        HAL_NVIC_SetPriority(spi_drv->config->dma_rx->dma_irq, 0, 0);        HAL_NVIC_EnableIRQ(spi_drv->config->dma_rx->dma_irq);    }    if (spi_drv->spi_dma_flag & SPI_USING_TX_DMA_FLAG)    {        HAL_DMA_Init(&spi_drv->dma.handle_tx);        __HAL_LINKDMA(&spi_drv->handle, hdmatx, spi_drv->dma.handle_tx);        /* NVIC configuration for DMA transfer complete interrupt */        HAL_NVIC_SetPriority(spi_drv->config->dma_tx->dma_irq, 0, 1);        HAL_NVIC_EnableIRQ(spi_drv->config->dma_tx->dma_irq);    }    __HAL_SPI_ENABLE(spi_handle);    LOG_D("%s init done", spi_drv->config->bus_name);    return RT_EOK;}

/**  * @brief  AUDIO IN I2S MSP Init.  * @param  None  * @retval None  */static void I2S2_MspInit(void){  static DMA_HandleTypeDef hdma_i2sRx;  GPIO_InitTypeDef  GPIO_InitStruct;  I2S_HandleTypeDef *hi2s = &hAudioInI2s;  /* Enable the I2S2 peripheral clock */  I2S2_CLK_ENABLE();  /* Enable I2S GPIO clocks */  I2S2_SCK_GPIO_CLK_ENABLE();  I2S2_MOSI_GPIO_CLK_ENABLE();    /* I2S2 pins configuration: SCK and MOSI pins ------------------------------*/  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull = GPIO_NOPULL;  GPIO_InitStruct.Speed     = GPIO_SPEED_FAST;  GPIO_InitStruct.Pin = I2S2_SCK_PIN;   GPIO_InitStruct.Alternate  = I2S2_SCK_AF;  HAL_GPIO_Init(I2S2_SCK_GPIO_PORT, &GPIO_InitStruct);    GPIO_InitStruct.Pin = I2S2_MOSI_PIN ;  GPIO_InitStruct.Alternate  = I2S2_MOSI_AF;  HAL_GPIO_Init(I2S2_MOSI_GPIO_PORT, &GPIO_InitStruct);   /* Enable the DMA clock */  I2S2_DMAx_CLK_ENABLE();      if(hi2s->Instance == I2S2)  {    /* Configure the hdma_i2sRx handle parameters */       hdma_i2sRx.Init.Channel             = I2S2_DMAx_CHANNEL;    hdma_i2sRx.Init.Direction           = DMA_PERIPH_TO_MEMORY;    hdma_i2sRx.Init.PeriphInc           = DMA_PINC_DISABLE;    hdma_i2sRx.Init.MemInc              = DMA_MINC_ENABLE;    hdma_i2sRx.Init.PeriphDataAlignment = I2S2_DMAx_PERIPH_DATA_SIZE;    hdma_i2sRx.Init.MemDataAlignment    = I2S2_DMAx_MEM_DATA_SIZE;    hdma_i2sRx.Init.Mode                = DMA_CIRCULAR;    hdma_i2sRx.Init.Priority            = DMA_PRIORITY_HIGH;    hdma_i2sRx.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;             hdma_i2sRx.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;    hdma_i2sRx.Init.MemBurst            = DMA_MBURST_SINGLE;    hdma_i2sRx.Init.PeriphBurst         = DMA_MBURST_SINGLE;         hdma_i2sRx.Instance = I2S2_DMAx_STREAM;        /* Associate the DMA handle */    __HAL_LINKDMA(hi2s, hdmarx, hdma_i2sRx);        /* Deinitialize the Stream for new transfer */    HAL_DMA_DeInit(&hdma_i2sRx);        /* Configure the DMA Stream */    HAL_DMA_Init(&hdma_i2sRx);        }    /* I2S DMA IRQ Channel configuration */  HAL_NVIC_SetPriority(I2S2_DMAx_IRQ, AUDIO_IN_IRQ_PREPRIO, 0);  HAL_NVIC_EnableIRQ(I2S2_DMAx_IRQ); }

/**  * @brief ADC MSP initialization  *        This function configures the hardware resources used in this example:  *          - Enable clock of ADC peripheral  *          - Configure the GPIO associated to the peripheral channels  *          - Configure the DMA associated to the peripheral  *          - Configure the NVIC associated to the peripheral interruptions  * @param hadc: ADC handle pointer  * @retval None  */void HAL_ADC_MspInit(ADC_HandleTypeDef *hadc){  GPIO_InitTypeDef          GPIO_InitStruct;  static DMA_HandleTypeDef  DmaHandle;  RCC_PeriphCLKInitTypeDef  PeriphClkInit;    /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable clock of GPIO associated to the peripheral channels */  ADCx_CHANNELa_GPIO_CLK_ENABLE();    /* Enable clock of ADCx peripheral */  ADCx_CLK_ENABLE();  /* Note: In case of usage of asynchronous clock derived from ADC dedicated  */  /*       PLL 72MHz, with ADC setting                                        */  /*       "AdcHandle.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1",            */  /*       the clock source has to be enabled at RCC top level using macro    */  /*       "__HAL_RCC_ADC12_CONFIG(RCC_ADC12PLLCLK_DIV1)" or function         */  /*       "HAL_RCCEx_PeriphCLKConfig()" (refer to comments in file           */  /*       "stm32f3_hal_adc.c_ex" header).                                    */    /* Enable asynchronous clock source of ADCx */  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_ADC12;  PeriphClkInit.Adc12ClockSelection = RCC_ADC12PLLCLK_DIV1;  HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit);  /* Enable clock of DMA associated to the peripheral */  ADCx_DMA_CLK_ENABLE();    /*##-2- Configure peripheral GPIO ##########################################*/  /* Configure GPIO pin of the selected ADC channel */  GPIO_InitStruct.Pin = ADCx_CHANNELa_PIN;  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;  GPIO_InitStruct.Pull = GPIO_NOPULL;  HAL_GPIO_Init(ADCx_CHANNELa_GPIO_PORT, &GPIO_InitStruct);    /*##-3- Configure the DMA ##################################################*/  /* Configure DMA parameters */  DmaHandle.Instance = ADCx_DMA;  DmaHandle.Init.Direction           = DMA_PERIPH_TO_MEMORY;  DmaHandle.Init.PeriphInc           = DMA_PINC_DISABLE;  DmaHandle.Init.MemInc              = DMA_MINC_ENABLE;  DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;   /* Transfer from ADC by half-word to match with ADC configuration: ADC resolution 10 or 12 bits */  DmaHandle.Init.MemDataAlignment    = DMA_MDATAALIGN_HALFWORD;   /* Transfer to memory by half-word to match with buffer variable type: half-word */  DmaHandle.Init.Mode                = DMA_CIRCULAR;              /* DMA in circular mode to match with ADC configuration: DMA continuous requests */  DmaHandle.Init.Priority            = DMA_PRIORITY_HIGH;    /* Deinitialize  & Initialize the DMA for new transfer */  HAL_DMA_DeInit(&DmaHandle);  HAL_DMA_Init(&DmaHandle);  /* Associate the initialized DMA handle to the ADC handle */  __HAL_LINKDMA(hadc, DMA_Handle, DmaHandle);    /*##-4- Configure the NVIC #################################################*/  /* NVIC configuration for DMA interrupt (transfer completion or error) */  /* Priority: high-priority */  HAL_NVIC_SetPriority(ADCx_DMA_IRQn, 1, 0);  HAL_NVIC_EnableIRQ(ADCx_DMA_IRQn);    /* NVIC configuration for ADC interrupt */  /* Priority: high-priority */  HAL_NVIC_SetPriority(ADCx_IRQn, 0, 0);  HAL_NVIC_EnableIRQ(ADCx_IRQn);}

void HAL_UART_MspInit(UART_HandleTypeDef* huart){  GPIO_InitTypeDef GPIO_InitStruct;  if(huart->Instance==USART3)  {  /* USER CODE BEGIN USART3_MspInit 0 */  /* USER CODE END USART3_MspInit 0 */    /* Peripheral clock enable */    __USART3_CLK_ENABLE();      /**USART3 GPIO Configuration        PB10     ------> USART3_TX    PB11     ------> USART3_RX    PB13     ------> USART3_CTS    PB14     ------> USART3_RTS     */    GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_PULLUP;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF7_USART3;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_usart3_rx.Instance = DMA1_Stream1;    hdma_usart3_rx.Init.Channel = DMA_CHANNEL_4;    hdma_usart3_rx.Init.Direction = DMA_PERIPH_TO_MEMORY;    hdma_usart3_rx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_usart3_rx.Init.MemInc = DMA_MINC_ENABLE;    hdma_usart3_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_usart3_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_usart3_rx.Init.Mode = DMA_CIRCULAR;    hdma_usart3_rx.Init.Priority = DMA_PRIORITY_LOW;    hdma_usart3_rx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;    hdma_usart3_rx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;    hdma_usart3_rx.Init.MemBurst = DMA_MBURST_SINGLE;    hdma_usart3_rx.Init.PeriphBurst = DMA_PBURST_SINGLE;    HAL_DMA_Init(&hdma_usart3_rx);    __HAL_LINKDMA(huart,hdmarx,hdma_usart3_rx);    hdma_usart3_tx.Instance = DMA1_Stream3;    hdma_usart3_tx.Init.Channel = DMA_CHANNEL_4;    hdma_usart3_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma_usart3_tx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_usart3_tx.Init.MemInc = DMA_MINC_ENABLE;    hdma_usart3_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_usart3_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_usart3_tx.Init.Mode = DMA_CIRCULAR;    hdma_usart3_tx.Init.Priority = DMA_PRIORITY_LOW;    hdma_usart3_tx.Init.FIFOMode = DMA_FIFOMODE_ENABLE;    hdma_usart3_tx.Init.FIFOThreshold = DMA_FIFO_THRESHOLD_FULL;    hdma_usart3_tx.Init.MemBurst = DMA_MBURST_SINGLE;    hdma_usart3_tx.Init.PeriphBurst = DMA_PBURST_SINGLE;    HAL_DMA_Init(&hdma_usart3_tx);    __HAL_LINKDMA(huart,hdmatx,hdma_usart3_tx);    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(USART3_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(USART3_IRQn);  /* USER CODE BEGIN USART3_MspInit 1 */  /* USER CODE END USART3_MspInit 1 */  }}

/**  * @brief RTC MSP Initialization  *        This function configures the hardware resources used in this example  * @param hrtc: RTC handle pointer  *  * @note  Care must be taken when HAL_RCCEx_PeriphCLKConfig() is used to select  *        the RTC clock source; in this case the Backup domain will be reset in  *        order to modify the RTC Clock source, as consequence RTC registers (including  *        the backup registers) and RCC_BDCR register are set to their reset values.  *  * @retval None  */void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc){  RCC_OscInitTypeDef        RCC_OscInitStruct;  RCC_PeriphCLKInitTypeDef  PeriphClkInitStruct;    /*##-1- Enables the PWR Clock and Enables access to the backup domain ###################################*/  /* To change the source clock of the RTC feature (LSE, LSI), You have to:     - Enable the power clock using __HAL_RCC_PWR_CLK_ENABLE()     - Enable write access using HAL_PWR_EnableBkUpAccess() function before to       configure the RTC clock source (to be done once after reset).     - Reset the Back up Domain using __HAL_RCC_BACKUPRESET_FORCE() and       __HAL_RCC_BACKUPRESET_RELEASE().     - Configure the needed RTC clock source */  __HAL_RCC_PWR_CLK_ENABLE();  HAL_PWR_EnableBkUpAccess();    /*##-2- Configue LSE/LSI as RTC clock soucre ###############################*/#ifdef RTC_CLOCK_SOURCE_LSE  RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSEState = RCC_LSE_ON;  RCC_OscInitStruct.LSIState = RCC_LSI_OFF;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {    Error_Handler();  }    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {    Error_Handler();  }#elif defined (RTC_CLOCK_SOURCE_LSI)  RCC_OscInitStruct.OscillatorType =  RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSIState = RCC_LSI_ON;  RCC_OscInitStruct.LSEState = RCC_LSE_OFF;  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)  {    Error_Handler();  }    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;  if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)  {    Error_Handler();  }#else#error Please select the RTC Clock source inside the main.h file#endif /*RTC_CLOCK_SOURCE_LSE*/    /*##-2- Enable RTC peripheral Clocks #######################################*/  /* Enable RTC Clock */  __HAL_RCC_RTC_ENABLE();    /*##-4- Configure the NVIC for RTC Alarm ###################################*/  HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0x0F, 0);  HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);}

void HAL_UART_MspInit(UART_HandleTypeDef* huart){  GPIO_InitTypeDef GPIO_InitStruct;  if(huart->Instance==UART4)  {  /* USER CODE BEGIN UART4_MspInit 0 */  /* USER CODE END UART4_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_UART4_CLK_ENABLE();      /**UART4 GPIO Configuration        PA0-WKUP     ------> UART4_TX    PA1     ------> UART4_RX     */    GPIO_InitStruct.Pin = COMMS_TX_U4_Pin|COMMS_RX_U4_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_PULLUP;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF8_UART4;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_uart4_tx.Instance = DMA1_Stream4;    hdma_uart4_tx.Init.Channel = DMA_CHANNEL_4;    hdma_uart4_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma_uart4_tx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_uart4_tx.Init.MemInc = DMA_MINC_ENABLE;    hdma_uart4_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_uart4_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_uart4_tx.Init.Mode = DMA_NORMAL;    hdma_uart4_tx.Init.Priority = DMA_PRIORITY_LOW;    hdma_uart4_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    if (HAL_DMA_Init(&hdma_uart4_tx) != HAL_OK)    {      Error_Handler();    }    __HAL_LINKDMA(huart,hdmatx,hdma_uart4_tx);    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(UART4_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(UART4_IRQn);  /* USER CODE BEGIN UART4_MspInit 1 */  /* USER CODE END UART4_MspInit 1 */  }  else if(huart->Instance==USART1)  {  /* USER CODE BEGIN USART1_MspInit 0 */  /* USER CODE END USART1_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_USART1_CLK_ENABLE();      /**USART1 GPIO Configuration        PA9     ------> USART1_TX    PA10     ------> USART1_RX     */    GPIO_InitStruct.Pin = EPS_TX_U1_Pin|EPS_RX_U1_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_PULLUP;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF7_USART1;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);    /* Peripheral DMA init*/      hdma_usart1_tx.Instance = DMA2_Stream7;    hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;    hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;    hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;    hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;    hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;    hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;    hdma_usart1_tx.Init.Mode = DMA_NORMAL;    hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;    hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;    if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK)    {      Error_Handler();    }    __HAL_LINKDMA(huart,hdmatx,hdma_usart1_tx);    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(USART1_IRQn);  /* USER CODE BEGIN USART1_MspInit 1 */  /* USER CODE END USART1_MspInit 1 */  }  else if(huart->Instance==USART2)  {  /* USER CODE BEGIN USART2_MspInit 0 */  /* USER CODE END USART2_MspInit 0 */    /* Peripheral clock enable *///.........这里部分代码省略.........

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* htim_base){  if(htim_base->Instance==TIM1)  {  /* USER CODE BEGIN TIM1_MspInit 0 */  /* USER CODE END TIM1_MspInit 0 */    /* Peripheral clock enable */    __TIM1_CLK_ENABLE();    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);    HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);    HAL_NVIC_SetPriority(TIM1_CC_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM1_CC_IRQn);  /* USER CODE BEGIN TIM1_MspInit 1 */  /* USER CODE END TIM1_MspInit 1 */  }  else if(htim_base->Instance==TIM4)  {  /* USER CODE BEGIN TIM4_MspInit 0 */  /* USER CODE END TIM4_MspInit 0 */    /* Peripheral clock enable */    __TIM4_CLK_ENABLE();    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM4_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM4_IRQn);  /* USER CODE BEGIN TIM4_MspInit 1 */  /* USER CODE END TIM4_MspInit 1 */  }  else if(htim_base->Instance==TIM6)  {  /* USER CODE BEGIN TIM6_MspInit 0 */  /* USER CODE END TIM6_MspInit 0 */    /* Peripheral clock enable */    __TIM6_CLK_ENABLE();    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM6_DAC_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM6_DAC_IRQn);  /* USER CODE BEGIN TIM6_MspInit 1 */  /* USER CODE END TIM6_MspInit 1 */  }  else if(htim_base->Instance==TIM7)  {  /* USER CODE BEGIN TIM7_MspInit 0 */  /* USER CODE END TIM7_MspInit 0 */    /* Peripheral clock enable */    __TIM7_CLK_ENABLE();  /* USER CODE BEGIN TIM7_MspInit 1 */  /* USER CODE END TIM7_MspInit 1 */  }  else if(htim_base->Instance==TIM9)  {  /* USER CODE BEGIN TIM9_MspInit 0 */  /* USER CODE END TIM9_MspInit 0 */    /* Peripheral clock enable */    __TIM9_CLK_ENABLE();    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM1_BRK_TIM9_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM1_BRK_TIM9_IRQn);  /* USER CODE BEGIN TIM9_MspInit 1 */  /* USER CODE END TIM9_MspInit 1 */  }  else if(htim_base->Instance==TIM10)  {  /* USER CODE BEGIN TIM10_MspInit 0 */  /* USER CODE END TIM10_MspInit 0 */    /* Peripheral clock enable */    __TIM10_CLK_ENABLE();    /* Peripheral interrupt init*/    HAL_NVIC_SetPriority(TIM1_UP_TIM10_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);  /* USER CODE BEGIN TIM10_MspInit 1 */  /* USER CODE END TIM10_MspInit 1 */  }  else if(htim_base->Instance==TIM11)  {  /* USER CODE BEGIN TIM11_MspInit 0 */  /* USER CODE END TIM11_MspInit 0 */    /* Peripheral clock enable */    __TIM11_CLK_ENABLE();//.........这里部分代码省略.........

/**   * Enable DMA controller clock  */void MX_DMA_Init(void) {  /* DMA controller clock enable */  __HAL_RCC_DMA1_CLK_ENABLE();  __HAL_RCC_DMA2_CLK_ENABLE();  /* DMA interrupt init */  /* DMA1_Stream0_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);  /* DMA1_Stream1_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);  /* DMA1_Stream2_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream2_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream2_IRQn);  /* DMA1_Stream3_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream3_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream3_IRQn);  /* DMA1_Stream4_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);  /* DMA1_Stream5_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);  /* DMA1_Stream6_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream6_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream6_IRQn);  /* DMA1_Stream7_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA1_Stream7_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA1_Stream7_IRQn);  /* DMA2_Stream0_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);  /* DMA2_Stream1_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream1_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream1_IRQn);  /* DMA2_Stream2_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream2_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream2_IRQn);  /* DMA2_Stream5_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);  /* DMA2_Stream6_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);  /* DMA2_Stream7_IRQn interrupt configuration */  HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 5, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);}

void CSI_Irq_Enable(){	HAL_NVIC_SetPriority(CSI_IRQn, 0);	HAL_NVIC_EnableIRQ(CSI_IRQn);}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim) {    __HAL_RCC_TIM5_CLK_ENABLE();    HAL_NVIC_SetPriority(TIM5_IRQn, TICK_INT_PRIORITY, 0);    HAL_NVIC_EnableIRQ(TIM5_IRQn);}

void HAL_CRYP_MspInit(CRYP_HandleTypeDef *hcryp){  static DMA_HandleTypeDef   hdmaIn;  static DMA_HandleTypeDef   hdmaOut;    /*##-1- Enable peripherals Clock ###########################################*/  /* Enable CRYP clock */  __HAL_RCC_CRYP_CLK_ENABLE();      /* Enable DMA2 clocks */  __HAL_RCC_DMA2_CLK_ENABLE();    /*##-2- Configure the DMA streams ##########################################*/  /***************** Configure common DMA In parameters ***********************/  hdmaIn.Init.Channel             = DMA_CHANNEL_2;  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_HIGH;  hdmaIn.Init.FIFOMode            = DMA_FIFOMODE_ENABLE;  hdmaIn.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_HALFFULL;  hdmaIn.Init.MemBurst            = DMA_MBURST_SINGLE;  hdmaIn.Init.PeriphBurst         = DMA_PBURST_SINGLE;  hdmaIn.Instance = DMA2_Stream6;    /* Associate the DMA handle */  __HAL_LINKDMA(hcryp, hdmain, hdmaIn);    /* Configure the DMA Stream */  HAL_DMA_Init(hcryp->hdmain);          /* NVIC configuration for DMA Input data interrupt */  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0x0F, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);    /***************** Configure common DMA Out parameters **********************/  hdmaOut.Init.Channel             = DMA_CHANNEL_2;  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.FIFOMode            = DMA_FIFOMODE_ENABLE;  hdmaOut.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_HALFFULL;  hdmaOut.Init.MemBurst            = DMA_MBURST_SINGLE;  hdmaOut.Init.PeriphBurst         = DMA_PBURST_SINGLE;  hdmaOut.Instance = DMA2_Stream5;    /* Associate the DMA handle */  __HAL_LINKDMA(hcryp, hdmaout, hdmaOut);    /* Configure the DMA Stream */  HAL_DMA_Init(&hdmaOut);  /*##-3- Configure the NVIC for DMA #########################################*/  /* NVIC configuration for DMA output data interrupt */  HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 0x0F, 0);  HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);}

/**  * @brief I2C 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   *           - NVIC configuration for DMA interrupt request enable  * @param hi2c: I2C handle pointer  * @retval None  */void HAL_I2C_MspInit(I2C_HandleTypeDef *hi2c){  GPIO_InitTypeDef  GPIO_InitStruct;  RCC_PeriphCLKInitTypeDef  RCC_PeriphCLKInitStruct;  static DMA_HandleTypeDef hdma_tx;  static DMA_HandleTypeDef hdma_rx;  /*##-1- Configure the I2C clock source. The clock is derived from the SYSCLK #*/  RCC_PeriphCLKInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2Cx;  RCC_PeriphCLKInitStruct.I2c1ClockSelection = RCC_I2CxCLKSOURCE_SYSCLK;  HAL_RCCEx_PeriphCLKConfig(&RCC_PeriphCLKInitStruct);    /*##-2- Enable peripherals and GPIO Clocks #################################*/  /* Enable GPIO TX/RX clock */  I2Cx_SCL_GPIO_CLK_ENABLE();  I2Cx_SDA_GPIO_CLK_ENABLE();  /* Enable I2Cx clock */  I2Cx_CLK_ENABLE();   /* Enable DMAx clock */  I2Cx_DMA_CLK_ENABLE();       /*##-3- Configure peripheral GPIO ##########################################*/    /* I2C TX GPIO pin configuration  */  GPIO_InitStruct.Pin       = I2Cx_SCL_PIN;  GPIO_InitStruct.Mode      = GPIO_MODE_AF_OD;  GPIO_InitStruct.Pull      = GPIO_PULLUP;  GPIO_InitStruct.Speed     = GPIO_SPEED_HIGH;  GPIO_InitStruct.Alternate = I2Cx_SCL_SDA_AF;    HAL_GPIO_Init(I2Cx_SCL_GPIO_PORT, &GPIO_InitStruct);      /* I2C RX GPIO pin configuration  */  GPIO_InitStruct.Pin              = I2Cx_SDA_PIN;  GPIO_InitStruct.Alternate        = I2Cx_SCL_SDA_AF;      HAL_GPIO_Init(I2Cx_SDA_GPIO_PORT, &GPIO_InitStruct);      /*##-4- Configure the DMA streams ##########################################*/  /* Configure the DMA handler for Transmission process */  hdma_tx.Instance                 = I2Cx_DMA_CHANNEL_TX;    hdma_tx.Init.Direction           = DMA_MEMORY_TO_PERIPH;  hdma_tx.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_tx.Init.MemInc              = DMA_MINC_ENABLE;  hdma_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_tx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma_tx.Init.Mode                = DMA_NORMAL;  hdma_tx.Init.Priority            = DMA_PRIORITY_LOW;    HAL_DMA_Init(&hdma_tx);       /* Associate the initialized DMA handle to the the I2C handle */  __HAL_LINKDMA(hi2c, hdmatx, hdma_tx);      /* Configure the DMA handler for Transmission process */  hdma_rx.Instance                 = I2Cx_DMA_CHANNEL_RX;    hdma_rx.Init.Direction           = DMA_PERIPH_TO_MEMORY;  hdma_rx.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma_rx.Init.MemInc              = DMA_MINC_ENABLE;  hdma_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_rx.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma_rx.Init.Mode                = DMA_NORMAL;  hdma_rx.Init.Priority            = DMA_PRIORITY_HIGH;  HAL_DMA_Init(&hdma_rx);      /* Associate the initialized DMA handle to the the I2C handle */  __HAL_LINKDMA(hi2c, hdmarx, hdma_rx);      /*##-5- Configure the NVIC for DMA #########################################*/  /* NVIC configuration for DMA transfer complete interrupt (I2Cx_TX) */  HAL_NVIC_SetPriority(I2Cx_DMA_TX_IRQn, 0, 1);  HAL_NVIC_EnableIRQ(I2Cx_DMA_TX_IRQn);      /* NVIC configuration for DMA transfer complete interrupt (I2Cx_RX) */  HAL_NVIC_SetPriority(I2Cx_DMA_RX_IRQn, 0, 0);     HAL_NVIC_EnableIRQ(I2Cx_DMA_RX_IRQn);}

/**  * @brief  This function configures the TIM3 as a time base source.   *         The time source is configured  to have 1ms time base with a dedicated   *         Tick interrupt priority.   * @note   This function is called  automatically at the beginning of program after  *         reset by HAL_Init() or at any time when clock is configured, by HAL_RCC_ClockConfig().   * @param  TickPriority: Tick interrupt priority.  * @retval HAL status  */HAL_StatusTypeDef HAL_InitTick (uint32_t TickPriority){  RCC_ClkInitTypeDef    clkconfig;  uint32_t              uwTimclock, uwAPB1Prescaler = 0;  uint32_t              uwPrescalerValue = 0;  uint32_t              pFLatency;      /*Configure the TIM3 IRQ priority */  HAL_NVIC_SetPriority(TIM3_IRQn, TickPriority ,0);    /* Enable the TIM3 global Interrupt */  HAL_NVIC_EnableIRQ(TIM3_IRQn);    /* Enable TIM3 clock */  __HAL_RCC_TIM3_CLK_ENABLE();    /* Get clock configuration */  HAL_RCC_GetClockConfig(&clkconfig, &pFLatency);    /* Get APB1 prescaler */  uwAPB1Prescaler = clkconfig.APB1CLKDivider;    /* Compute TIM3 clock */  if (uwAPB1Prescaler == RCC_HCLK_DIV1)   {    uwTimclock = HAL_RCC_GetPCLK1Freq();  }  else  {    uwTimclock = 2*HAL_RCC_GetPCLK1Freq();  }  /* Compute the prescaler value to have TIM3 counter clock equal to 1MHz */  uwPrescalerValue = (uint32_t) ((uwTimclock / 1000000) - 1);    /* Initialize TIM3 */  TimHandle.Instance = TIM3;      /* Initialize TIMx peripheral as follow:       + Period = [(TIM3CLK/1000) - 1]. to have a (1/1000) s time base.       + Prescaler = (uwTimclock/1000000 - 1) to have a 1MHz counter clock.       + ClockDivision = 0       + Counter direction = Up  */  TimHandle.Init.Period = (1000000 / 1000) - 1;  TimHandle.Init.Prescaler = uwPrescalerValue;  TimHandle.Init.ClockDivision = 0;  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)  {    /* Initialization Error */    Error_Handler();  }    /* Start the TIM time Base generation in interrupt mode */  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)  {    /* Starting Error */    Error_Handler();  }    /* Return function status */  return HAL_OK;}

/**  * @brief  Initializes the PCD MSP.  * @param  hpcd: PCD handle  * @retval None  */void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd){  GPIO_InitTypeDef  GPIO_InitStruct;    if(hpcd->Instance == USB_OTG_FS)  {    /* Configure USB FS GPIOs */    __HAL_RCC_GPIOA_CLK_ENABLE();        /* Configure DM DP Pins */    GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* Enable USB FS Clock */    __HAL_RCC_USB_OTG_FS_CLK_ENABLE();        /* Set USBFS Interrupt priority */    HAL_NVIC_SetPriority(OTG_FS_IRQn, 5, 0);        /* Enable USBFS Interrupt */    HAL_NVIC_EnableIRQ(OTG_FS_IRQn);        if(hpcd->Init.low_power_enable == 1)    {      /* Enable EXTI Line 18 for USB wakeup*/      __HAL_USB_OTG_FS_WAKEUP_EXTI_CLEAR_FLAG();      __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_RISING_EDGE();      __HAL_USB_OTG_FS_WAKEUP_EXTI_ENABLE_IT();            /* Set EXTI Wakeup Interrupt priority*/      HAL_NVIC_SetPriority(OTG_FS_WKUP_IRQn, 0, 0);            /* Enable EXTI Interrupt */      HAL_NVIC_EnableIRQ(OTG_FS_WKUP_IRQn);              }  }  else if(hpcd->Instance == USB_OTG_HS)  {    /* Configure USB FS GPIOs */    __HAL_RCC_GPIOA_CLK_ENABLE();    __HAL_RCC_GPIOB_CLK_ENABLE();    __HAL_RCC_GPIOC_CLK_ENABLE();    __HAL_RCC_GPIOH_CLK_ENABLE();        /* CLK */    GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);        /* D0 */    GPIO_InitStruct.Pin = GPIO_PIN_3;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);        /* D1 D2 D3 D4 D5 D6 D7 */    GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |/      GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);        /* STP */    GPIO_InitStruct.Pin = GPIO_PIN_0;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);        /* NXT */    GPIO_InitStruct.Pin = GPIO_PIN_4;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);        /* DIR */    GPIO_InitStruct.Pin = GPIO_PIN_2;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);        __HAL_RCC_USB_OTG_HS_ULPI_CLK_ENABLE();    //.........这里部分代码省略.........

/**  * @brief QSPI MSP Initialization  *        This function configures the hardware resources used in this example:  *           - Peripheral's clock enable  *           - Peripheral's GPIO Configuration  *           - DMA configuration for requests by peripheral   *           - NVIC configuration for DMA and QSPI interrupts  * @param hqspi: QSPI handle pointer  * @retval None  */void HAL_QSPI_MspInit(QSPI_HandleTypeDef *hqspi){  GPIO_InitTypeDef GPIO_InitStruct;  static DMA_HandleTypeDef hdma;  /*##-1- Enable peripherals and GPIO Clocks #################################*/  /* Enable the QuadSPI memory interface clock */  QSPI_CLK_ENABLE();  /* Reset the QuadSPI memory interface */  QSPI_FORCE_RESET();  QSPI_RELEASE_RESET();  /* Enable GPIO clocks */  QSPI_CS_GPIO_CLK_ENABLE();  QSPI_CLK_GPIO_CLK_ENABLE();  QSPI_D0_GPIO_CLK_ENABLE();  QSPI_D1_GPIO_CLK_ENABLE();  QSPI_D2_GPIO_CLK_ENABLE();  QSPI_D3_GPIO_CLK_ENABLE();  /* Enable DMA clock */  QSPI_DMA_CLK_ENABLE();     /*##-2- Configure peripheral GPIO ##########################################*/  /* QSPI CS GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_CS_PIN;  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;  GPIO_InitStruct.Pull      = GPIO_PULLUP;  GPIO_InitStruct.Speed     = GPIO_SPEED_HIGH;  GPIO_InitStruct.Alternate = GPIO_AF10_QSPI;  HAL_GPIO_Init(QSPI_CS_GPIO_PORT, &GPIO_InitStruct);  /* QSPI CLK GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_CLK_PIN;  GPIO_InitStruct.Pull      = GPIO_NOPULL;  GPIO_InitStruct.Alternate = GPIO_AF9_QSPI;  HAL_GPIO_Init(QSPI_CLK_GPIO_PORT, &GPIO_InitStruct);  /* QSPI D0 GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_D0_PIN;  GPIO_InitStruct.Alternate = GPIO_AF10_QSPI;  HAL_GPIO_Init(QSPI_D0_GPIO_PORT, &GPIO_InitStruct);  /* QSPI D1 GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_D1_PIN;  GPIO_InitStruct.Alternate = GPIO_AF10_QSPI;  HAL_GPIO_Init(QSPI_D1_GPIO_PORT, &GPIO_InitStruct);  /* QSPI D2 GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_D2_PIN;  GPIO_InitStruct.Alternate = GPIO_AF9_QSPI;  HAL_GPIO_Init(QSPI_D2_GPIO_PORT, &GPIO_InitStruct);  /* QSPI D3 GPIO pin configuration  */  GPIO_InitStruct.Pin       = QSPI_D3_PIN;  GPIO_InitStruct.Alternate = GPIO_AF9_QSPI;  HAL_GPIO_Init(QSPI_D3_GPIO_PORT, &GPIO_InitStruct);  /*##-3- Configure the NVIC for QSPI #########################################*/  /* NVIC configuration for QSPI interrupt */  HAL_NVIC_SetPriority(QUADSPI_IRQn, 0x0F, 0);  HAL_NVIC_EnableIRQ(QUADSPI_IRQn);  /*##-4- Configure the DMA channel ###########################################*/  /* QSPI DMA channel configuration */  hdma.Init.Channel             = QSPI_DMA_CHANNEL;                       hdma.Init.PeriphInc           = DMA_PINC_DISABLE;  hdma.Init.MemInc              = DMA_MINC_ENABLE;  hdma.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma.Init.MemDataAlignment    = DMA_MDATAALIGN_BYTE;  hdma.Init.Mode                = DMA_NORMAL;  hdma.Init.Priority            = DMA_PRIORITY_LOW;  hdma.Init.FIFOMode            = DMA_FIFOMODE_DISABLE;        /* FIFO mode disabled     */  hdma.Init.FIFOThreshold       = DMA_FIFO_THRESHOLD_FULL;  hdma.Init.MemBurst            = DMA_MBURST_SINGLE;           /* Memory burst           */  hdma.Init.PeriphBurst         = DMA_PBURST_SINGLE;           /* Peripheral burst       */  hdma.Instance                 = QSPI_DMA_INSTANCE;  __HAL_LINKDMA(hqspi, hdma, hdma);  HAL_DMA_Init(&hdma);  /* NVIC configuration for DMA interrupt */  HAL_NVIC_SetPriority(QSPI_DMA_IRQ, 0x00, 0);  HAL_NVIC_EnableIRQ(QSPI_DMA_IRQ);}

//------------------------------------------------------------------------------------------------------------------------------------------------------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();}

void HAL_CAN_MspInit(CAN_HandleTypeDef* hcan){  GPIO_InitTypeDef GPIO_InitStruct;  if(hcan->Instance==CAN1)  {  /* USER CODE BEGIN CAN1_MspInit 0 */  /* USER CODE END CAN1_MspInit 0 */    /* Peripheral clock enable */    HAL_RCC_CAN1_CLK_ENABLED++;    if(HAL_RCC_CAN1_CLK_ENABLED==1){      __HAL_RCC_CAN1_CLK_ENABLE();    }      /**CAN1 GPIO Configuration        PB8     ------> CAN1_RX    PB9     ------> CAN1_TX     */    GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(CAN1_TX_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(CAN1_TX_IRQn);    HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);    HAL_NVIC_SetPriority(CAN1_RX1_IRQn, 0, 0);    HAL_NVIC_EnableIRQ(CAN1_RX1_IRQn);  /* USER CODE BEGIN CAN1_MspInit 1 */  /* USER CODE END CAN1_MspInit 1 */  }  else if(hcan->Instance==CAN2)  {  /* USER CODE BEGIN CAN2_MspInit 0 */  /* USER CODE END CAN2_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_CAN2_CLK_ENABLE();    HAL_RCC_CAN1_CLK_ENABLED++;    if(HAL_RCC_CAN1_CLK_ENABLED==1){      __HAL_RCC_CAN1_CLK_ENABLE();    }      /**CAN2 GPIO Configuration        PB5     ------> CAN2_RX    PB6     ------> CAN2_TX     */    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_6;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF9_CAN2;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);  /* USER CODE BEGIN CAN2_MspInit 1 */  /* USER CODE END CAN2_MspInit 1 */  }}

/**  * @brief  Initializes the HCD MSP.  * @param  hhcd: HCD handle  * @retval None  */void HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd){  GPIO_InitTypeDef  GPIO_InitStruct;    if(hhcd->Instance == USB_OTG_FS)  {    /* Configure USB FS GPIOs */    __HAL_RCC_GPIOA_CLK_ENABLE();    GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         GPIO_InitStruct.Pin = GPIO_PIN_10;    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;    GPIO_InitStruct.Pull = GPIO_PULLUP;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* Configure POWER_SWITCH IO pin */    BSP_IO_ConfigPin(OTG_FS1_POWER_SWITCH_PIN, IO_MODE_OUTPUT);        /* Enable USB FS Clocks */     __HAL_RCC_USB_OTG_FS_CLK_ENABLE();        /* Set USBFS Interrupt to the lowest priority */    HAL_NVIC_SetPriority(OTG_FS_IRQn, 5, 0);        /* Enable USBFS Interrupt */    HAL_NVIC_EnableIRQ(OTG_FS_IRQn);  }     else if(hhcd->Instance == USB_OTG_HS)  {#ifdef USE_USB_HS_IN_FS        /* Configure POWER_SWITCH IO pin */    BSP_IO_ConfigPin(OTG_FS2_POWER_SWITCH_PIN, IO_MODE_OUTPUT);    __HAL_RCC_GPIOB_CLK_ENABLE();        /*Configure GPIO for HS on FS mode*/    GPIO_InitStruct.Pin = GPIO_PIN_12  | GPIO_PIN_13  | GPIO_PIN_14 |GPIO_PIN_15;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF12_OTG_HS_FS;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    #else    /* Configure USB FS GPIOs */    __HAL_RCC_GPIOA_CLK_ENABLE();    __HAL_RCC_GPIOB_CLK_ENABLE();    __HAL_RCC_GPIOC_CLK_ENABLE();    __HAL_RCC_GPIOH_CLK_ENABLE();            __HAL_RCC_GPIOI_CLK_ENABLE();        /* CLK */    GPIO_InitStruct.Pin = GPIO_PIN_5;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* D0 */    GPIO_InitStruct.Pin = GPIO_PIN_3;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);         /* D1 D2 D3 D4 D5 D6 D7 */    GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |/                          GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);         /* STP */      GPIO_InitStruct.Pin = GPIO_PIN_0;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);         /* NXT */    GPIO_InitStruct.Pin = GPIO_PIN_4;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;    HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);   //.........这里部分代码省略.........

void HAL_SPI_MspInit(SPI_HandleTypeDef* hspi){  GPIO_InitTypeDef GPIO_InitStruct;  if(hspi->Instance==SPI1)  {  /* USER CODE BEGIN SPI1_MspInit 0 */  /* USER CODE END SPI1_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_SPI1_CLK_ENABLE();      /**SPI1 GPIO Configuration        PA5     ------> SPI1_SCK    PA6     ------> SPI1_MISO    PA7     ------> SPI1_MOSI     */    GPIO_InitStruct.Pin = ADC_SCK_SPI1_Pin|ADC_MISO_SPI1_Pin|ADC_MOSI_SPI1_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);  /* USER CODE BEGIN SPI1_MspInit 1 */  /* USER CODE END SPI1_MspInit 1 */  }  else if(hspi->Instance==SPI2)  {  /* USER CODE BEGIN SPI2_MspInit 0 */  /* USER CODE END SPI2_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_SPI2_CLK_ENABLE();      /**SPI2 GPIO Configuration        PB13     ------> SPI2_SCK    PB14     ------> SPI2_MISO    PB15     ------> SPI2_MOSI     */    GPIO_InitStruct.Pin = FLASH_SCK_SPI2_Pin|FLASH_MISO_SPI2_Pin|FLASH_MOSI_SPI2_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF5_SPI2;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);  /* USER CODE BEGIN SPI2_MspInit 1 */  /* USER CODE END SPI2_MspInit 1 */  }  else if(hspi->Instance==SPI3)  {  /* USER CODE BEGIN SPI3_MspInit 0 */  /* USER CODE END SPI3_MspInit 0 */    /* Peripheral clock enable */    __HAL_RCC_SPI3_CLK_ENABLE();      /**SPI3 GPIO Configuration        PB3     ------> SPI3_SCK    PB4     ------> SPI3_MISO    PB5     ------> SPI3_MOSI     */    GPIO_InitStruct.Pin = IAC_SCK_SPI3_Pin|IAC_MISO_SPI3_Pin|IAC_MOSI_SPI3_Pin;    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;    GPIO_InitStruct.Pull = GPIO_NOPULL;    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;    GPIO_InitStruct.Alternate = GPIO_AF6_SPI3;    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);    /* Peripheral interrupt init */    HAL_NVIC_SetPriority(SPI3_IRQn, 5, 0);    HAL_NVIC_EnableIRQ(SPI3_IRQn);  /* USER CODE BEGIN SPI3_MspInit 1 */  /* USER CODE END SPI3_MspInit 1 */  }}

//.........这里部分代码省略.........  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;#elif defined (RTC_CLOCK_SOURCE_LSI)  /* Configue LSI as RTC clock soucre */  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.LSIState = RCC_LSI_ON;  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;#elif defined (RTC_CLOCK_SOURCE_HSE)  /* Configue HSE as RTC clock soucre */  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;  RCC_OscInitStruct.HSEState = RCC_HSE_ON;  /* Ensure that RTC is clocked by 1MHz */  PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_1MHZ;#else#error Please select the RTC Clock source#endif /* RTC_CLOCK_SOURCE_LSE */  if(HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK)  {     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;    if(HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) == HAL_OK)    {      /* Enable RTC Clock */      __HAL_RCC_RTC_ENABLE();      /* The time base should be 1ms          Time base = ((RTC_ASYNCH_PREDIV + 1) * (RTC_SYNCH_PREDIV + 1)) / RTC_CLOCK          HSE as RTC clock            Time base = ((99 + 1) * (9 + 1)) / 1Mhz                     = 1ms         LSE as RTC clock            Time base = ((31 + 1) * (0 + 1)) / 32.768Khz                     = ~1ms         LSI as RTC clock            Time base = ((31 + 1) * (0 + 1)) / 32Khz                     = 1ms      */      hRTC_Handle.Instance = RTC;      hRTC_Handle.Init.HourFormat = RTC_HOURFORMAT_24;      hRTC_Handle.Init.AsynchPrediv = RTC_ASYNCH_PREDIV;      hRTC_Handle.Init.SynchPrediv = RTC_SYNCH_PREDIV;      hRTC_Handle.Init.OutPut = RTC_OUTPUT_DISABLE;      hRTC_Handle.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;      hRTC_Handle.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;      HAL_RTC_Init(&hRTC_Handle);      /* Disable the write protection for RTC registers */      __HAL_RTC_WRITEPROTECTION_DISABLE(&hRTC_Handle);      /* Disable the Wake-up Timer */      __HAL_RTC_WAKEUPTIMER_DISABLE(&hRTC_Handle);      /* In case of interrupt mode is used, the interrupt source must disabled */       __HAL_RTC_WAKEUPTIMER_DISABLE_IT(&hRTC_Handle,RTC_IT_WUT);      /* Wait till RTC WUTWF flag is set  */      while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(&hRTC_Handle, RTC_FLAG_WUTWF) == RESET)      {        if(counter++ == (SystemCoreClock /48U))         {          return HAL_ERROR;        }      }      /* Clear PWR wake up Flag */      __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);      /* Clear RTC Wake Up timer Flag */      __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&hRTC_Handle, RTC_FLAG_WUTF);      /* Configure the Wake-up Timer counter */      hRTC_Handle.Instance->WUTR = 0U;      /* Clear the Wake-up Timer clock source bits in CR register */      hRTC_Handle.Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;      /* Configure the clock source */      hRTC_Handle.Instance->CR |= (uint32_t)RTC_WAKEUPCLOCK_CK_SPRE_16BITS;      /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */      __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT();      __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_RISING_EDGE();      /* Configure the Interrupt in the RTC_CR register */      __HAL_RTC_WAKEUPTIMER_ENABLE_IT(&hRTC_Handle,RTC_IT_WUT);      /* Enable the Wake-up Timer */      __HAL_RTC_WAKEUPTIMER_ENABLE(&hRTC_Handle);      /* Enable the write protection for RTC registers */      __HAL_RTC_WRITEPROTECTION_ENABLE(&hRTC_Handle);      HAL_NVIC_SetPriority(RTC_WKUP_IRQn, TickPriority, 0U);      HAL_NVIC_EnableIRQ(RTC_WKUP_IRQn);       return HAL_OK;    }  }  return HAL_ERROR;}

static void BlueNRG_Init(){  int rc;  uint8_t bdaddr[] = {0x12, 0x34, 0x00, 0xE1, 0x80, 0x02};  uint16_t service_handle, dev_name_char_handle, appearance_char_handle;  const char *ble_name = "BlueNRG";  BSP_LED_On(LED3);  HCI_Init();  /* Enable and set EXTI for BlueNRG IRQ */  HAL_NVIC_SetPriority(BLUENRG_IRQ_EXTI_IRQn, 2, 0);  HAL_NVIC_EnableIRQ(BLUENRG_IRQ_EXTI_IRQn);  BlueNRG_RST();  BSP_LED_On(LED4);  rc = aci_hal_write_config_data(CONFIG_DATA_PUBADDR_OFFSET,                                 CONFIG_DATA_PUBADDR_LEN, bdaddr);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED4);  }  BSP_LED_On(LED5);  rc = aci_gatt_init();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED5);  }  BSP_LED_On(LED6);  rc = aci_gap_init(1, &service_handle, &dev_name_char_handle,                    &appearance_char_handle);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED6);  }  BSP_LED_Off(LED3);  rc = aci_gatt_update_char_value(service_handle, dev_name_char_handle,                                  0, strlen(ble_name), (uint8_t *)ble_name);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED3);  }  BSP_LED_Off(LED4);  rc = aci_gap_set_auth_requirement(MITM_PROTECTION_REQUIRED,                                    OOB_AUTH_DATA_ABSENT,                                    NULL,                                    7,                                    16,                                    USE_FIXED_PIN_FOR_PAIRING,                                    123456,                                    BONDING);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED4);  }  /* sensors have been initialized in HW_Init() */  BSP_LED_Off(LED5);  rc = Add_Acc_Service();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED5);  }  BSP_LED_Off(LED6);  rc = Add_Environmental_Sensor_Service();  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED6);  }  /* Init_User_Timer();  Start_User_Timer(); */  BSP_LED_On(LED3);  /* -2 dBm output power */  rc = aci_hal_set_tx_power_level(1, 4);  while (rc) {    HAL_Delay(100);    BSP_LED_Toggle(LED3);  }}