Vehicle Control Unit 0.01
This is the c library for controlling the car.
Loading...
Searching...
No Matches
Functions | Variables
stm32f7xx_hal_msp.c File Reference

This file provides code for the MSP Initialization and de-Initialization codes. More...

#include "main.h"
Include dependency graph for stm32f7xx_hal_msp.c:

Go to the source code of this file.

Functions

void HAL_MspInit (void)
 
void HAL_ADC_MspInit (ADC_HandleTypeDef *hadc)
 ADC MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_ADC_MspDeInit (ADC_HandleTypeDef *hadc)
 ADC MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_CAN_MspInit (CAN_HandleTypeDef *hcan)
 CAN MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_CAN_MspDeInit (CAN_HandleTypeDef *hcan)
 CAN MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_DAC_MspInit (DAC_HandleTypeDef *hdac)
 DAC MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_DAC_MspDeInit (DAC_HandleTypeDef *hdac)
 DAC MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_I2C_MspInit (I2C_HandleTypeDef *hi2c)
 I2C MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_I2C_MspDeInit (I2C_HandleTypeDef *hi2c)
 I2C MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_SPI_MspInit (SPI_HandleTypeDef *hspi)
 SPI MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_SPI_MspDeInit (SPI_HandleTypeDef *hspi)
 SPI MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_TIM_Base_MspInit (TIM_HandleTypeDef *htim_base)
 TIM_Base MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_TIM_Base_MspDeInit (TIM_HandleTypeDef *htim_base)
 TIM_Base MSP De-Initialization This function freeze the hardware resources used in this example. More...
 
void HAL_UART_MspInit (UART_HandleTypeDef *huart)
 UART MSP Initialization This function configures the hardware resources used in this example. More...
 
void HAL_UART_MspDeInit (UART_HandleTypeDef *huart)
 UART MSP De-Initialization This function freeze the hardware resources used in this example. More...
 

Variables

DMA_HandleTypeDef hdma_adc1
 
DMA_HandleTypeDef hdma_adc2
 
DMA_HandleTypeDef hdma_adc3
 
DMA_HandleTypeDef hdma_dac1
 
DMA_HandleTypeDef hdma_dac2
 
static uint32_t HAL_RCC_CAN1_CLK_ENABLED =0
 

Detailed Description

This file provides code for the MSP Initialization and de-Initialization codes.

Attention

Copyright (c) 2024 STMicroelectronics. All rights reserved.

This software is licensed under terms that can be found in the LICENSE file in the root directory of this software component. If no LICENSE file comes with this software, it is provided AS-IS.

Definition in file stm32f7xx_hal_msp.c.

Function Documentation

◆ HAL_ADC_MspDeInit()

void HAL_ADC_MspDeInit ( ADC_HandleTypeDef *  hadc)

ADC MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
hadcADC handle pointer
Return values
None

ADC1 GPIO Configuration PC0 ---—> ADC1_IN10 PC2 ---—> ADC1_IN12 PA0/WKUP ---—> ADC1_IN0 PA2 ---—> ADC1_IN2 PA6 ---—> ADC1_IN6 PC4 ---—> ADC1_IN14 PB0 ---—> ADC1_IN8

ADC2 GPIO Configuration PC1 ---—> ADC2_IN11 PC3 ---—> ADC2_IN13 PA1 ---—> ADC2_IN1 PA3 ---—> ADC2_IN3 PA7 ---—> ADC2_IN7 PC5 ---—> ADC2_IN15 PB1 ---—> ADC2_IN9

ADC3 GPIO Configuration PF3 ---—> ADC3_IN9 PF4 ---—> ADC3_IN14 PF5 ---—> ADC3_IN15 PF6 ---—> ADC3_IN4 PF7 ---—> ADC3_IN5 PF8 ---—> ADC3_IN6 PF9 ---—> ADC3_IN7 PF10 ---—> ADC3_IN8

Definition at line 273 of file stm32f7xx_hal_msp.c.

274{
275 if(hadc->Instance==ADC1)
276 {
277 /* USER CODE BEGIN ADC1_MspDeInit 0 */
278
279 /* USER CODE END ADC1_MspDeInit 0 */
280 /* Peripheral clock disable */
281 __HAL_RCC_ADC1_CLK_DISABLE();
282
292 HAL_GPIO_DeInit(GPIOC, GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_4);
293
294 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_6);
295
296 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_0);
297
298 /* ADC1 DMA DeInit */
299 HAL_DMA_DeInit(hadc->DMA_Handle);
300 /* USER CODE BEGIN ADC1_MspDeInit 1 */
301
302 /* USER CODE END ADC1_MspDeInit 1 */
303 }
304 else if(hadc->Instance==ADC2)
305 {
306 /* USER CODE BEGIN ADC2_MspDeInit 0 */
307
308 /* USER CODE END ADC2_MspDeInit 0 */
309 /* Peripheral clock disable */
310 __HAL_RCC_ADC2_CLK_DISABLE();
311
321 HAL_GPIO_DeInit(GPIOC, GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_5);
322
323 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_7);
324
325 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_1);
326
327 /* ADC2 DMA DeInit */
328 HAL_DMA_DeInit(hadc->DMA_Handle);
329 /* USER CODE BEGIN ADC2_MspDeInit 1 */
330
331 /* USER CODE END ADC2_MspDeInit 1 */
332 }
333 else if(hadc->Instance==ADC3)
334 {
335 /* USER CODE BEGIN ADC3_MspDeInit 0 */
336
337 /* USER CODE END ADC3_MspDeInit 0 */
338 /* Peripheral clock disable */
339 __HAL_RCC_ADC3_CLK_DISABLE();
340
351 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
352 |GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10);
353
354 /* ADC3 DMA DeInit */
355 HAL_DMA_DeInit(hadc->DMA_Handle);
356 /* USER CODE BEGIN ADC3_MspDeInit 1 */
357
358 /* USER CODE END ADC3_MspDeInit 1 */
359 }
360
361}

◆ HAL_ADC_MspInit()

void HAL_ADC_MspInit ( ADC_HandleTypeDef *  hadc)

ADC MSP Initialization This function configures the hardware resources used in this example.

Parameters
hadcADC handle pointer
Return values
None

ADC1 GPIO Configuration PC0 ---—> ADC1_IN10 PC2 ---—> ADC1_IN12 PA0/WKUP ---—> ADC1_IN0 PA2 ---—> ADC1_IN2 PA6 ---—> ADC1_IN6 PC4 ---—> ADC1_IN14 PB0 ---—> ADC1_IN8

ADC2 GPIO Configuration PC1 ---—> ADC2_IN11 PC3 ---—> ADC2_IN13 PA1 ---—> ADC2_IN1 PA3 ---—> ADC2_IN3 PA7 ---—> ADC2_IN7 PC5 ---—> ADC2_IN15 PB1 ---—> ADC2_IN9

ADC3 GPIO Configuration PF3 ---—> ADC3_IN9 PF4 ---—> ADC3_IN14 PF5 ---—> ADC3_IN15 PF6 ---—> ADC3_IN4 PF7 ---—> ADC3_IN5 PF8 ---—> ADC3_IN6 PF9 ---—> ADC3_IN7 PF10 ---—> ADC3_IN8

Definition at line 97 of file stm32f7xx_hal_msp.c.

98{
99 GPIO_InitTypeDef GPIO_InitStruct = {0};
100 if(hadc->Instance==ADC1)
101 {
102 /* USER CODE BEGIN ADC1_MspInit 0 */
103
104 /* USER CODE END ADC1_MspInit 0 */
105 /* Peripheral clock enable */
106 __HAL_RCC_ADC1_CLK_ENABLE();
107
108 __HAL_RCC_GPIOC_CLK_ENABLE();
109 __HAL_RCC_GPIOA_CLK_ENABLE();
110 __HAL_RCC_GPIOB_CLK_ENABLE();
120 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_4;
121 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
122 GPIO_InitStruct.Pull = GPIO_NOPULL;
123 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
124
125 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_6;
126 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
127 GPIO_InitStruct.Pull = GPIO_NOPULL;
128 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
129
130 GPIO_InitStruct.Pin = GPIO_PIN_0;
131 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
132 GPIO_InitStruct.Pull = GPIO_NOPULL;
133 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
134
135 /* ADC1 DMA Init */
136 /* ADC1 Init */
137 hdma_adc1.Instance = DMA2_Stream0;
138 hdma_adc1.Init.Channel = DMA_CHANNEL_0;
139 hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
140 hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
141 hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
142 hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
143 hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
144 hdma_adc1.Init.Mode = DMA_CIRCULAR;
145 hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
146 hdma_adc1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
147 if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
148 {
149 Error_Handler();
150 }
151
152 __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc1);
153
154 /* USER CODE BEGIN ADC1_MspInit 1 */
155
156 /* USER CODE END ADC1_MspInit 1 */
157 }
158 else if(hadc->Instance==ADC2)
159 {
160 /* USER CODE BEGIN ADC2_MspInit 0 */
161
162 /* USER CODE END ADC2_MspInit 0 */
163 /* Peripheral clock enable */
164 __HAL_RCC_ADC2_CLK_ENABLE();
165
166 __HAL_RCC_GPIOC_CLK_ENABLE();
167 __HAL_RCC_GPIOA_CLK_ENABLE();
168 __HAL_RCC_GPIOB_CLK_ENABLE();
178 GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_5;
179 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
180 GPIO_InitStruct.Pull = GPIO_NOPULL;
181 HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
182
183 GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_3|GPIO_PIN_7;
184 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
185 GPIO_InitStruct.Pull = GPIO_NOPULL;
186 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
187
188 GPIO_InitStruct.Pin = GPIO_PIN_1;
189 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
190 GPIO_InitStruct.Pull = GPIO_NOPULL;
191 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
192
193 /* ADC2 DMA Init */
194 /* ADC2 Init */
195 hdma_adc2.Instance = DMA2_Stream2;
196 hdma_adc2.Init.Channel = DMA_CHANNEL_1;
197 hdma_adc2.Init.Direction = DMA_PERIPH_TO_MEMORY;
198 hdma_adc2.Init.PeriphInc = DMA_PINC_DISABLE;
199 hdma_adc2.Init.MemInc = DMA_MINC_ENABLE;
200 hdma_adc2.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
201 hdma_adc2.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
202 hdma_adc2.Init.Mode = DMA_CIRCULAR;
203 hdma_adc2.Init.Priority = DMA_PRIORITY_LOW;
204 hdma_adc2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
205 if (HAL_DMA_Init(&hdma_adc2) != HAL_OK)
206 {
207 Error_Handler();
208 }
209
210 __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc2);
211
212 /* USER CODE BEGIN ADC2_MspInit 1 */
213
214 /* USER CODE END ADC2_MspInit 1 */
215 }
216 else if(hadc->Instance==ADC3)
217 {
218 /* USER CODE BEGIN ADC3_MspInit 0 */
219
220 /* USER CODE END ADC3_MspInit 0 */
221 /* Peripheral clock enable */
222 __HAL_RCC_ADC3_CLK_ENABLE();
223
224 __HAL_RCC_GPIOF_CLK_ENABLE();
235 GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
236 |GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10;
237 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
238 GPIO_InitStruct.Pull = GPIO_NOPULL;
239 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
240
241 /* ADC3 DMA Init */
242 /* ADC3 Init */
243 hdma_adc3.Instance = DMA2_Stream1;
244 hdma_adc3.Init.Channel = DMA_CHANNEL_2;
245 hdma_adc3.Init.Direction = DMA_PERIPH_TO_MEMORY;
246 hdma_adc3.Init.PeriphInc = DMA_PINC_DISABLE;
247 hdma_adc3.Init.MemInc = DMA_MINC_ENABLE;
248 hdma_adc3.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
249 hdma_adc3.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
250 hdma_adc3.Init.Mode = DMA_CIRCULAR;
251 hdma_adc3.Init.Priority = DMA_PRIORITY_LOW;
252 hdma_adc3.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
253 if (HAL_DMA_Init(&hdma_adc3) != HAL_OK)
254 {
255 Error_Handler();
256 }
257
258 __HAL_LINKDMA(hadc,DMA_Handle,hdma_adc3);
259
260 /* USER CODE BEGIN ADC3_MspInit 1 */
261
262 /* USER CODE END ADC3_MspInit 1 */
263 }
264
265}
Error_Handler
void Error_Handler(void)
This function is executed in case of error occurrence.
Definition: main.c:1496
hdma_adc1
DMA_HandleTypeDef hdma_adc1
Definition: main.c:64
hdma_adc3
DMA_HandleTypeDef hdma_adc3
Definition: AnalogSensor.h:69
hdma_adc2
DMA_HandleTypeDef hdma_adc2
Definition: AnalogSensor.h:69
Here is the call graph for this function:

◆ HAL_CAN_MspDeInit()

void HAL_CAN_MspDeInit ( CAN_HandleTypeDef *  hcan)

CAN MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
hcanCAN handle pointer
Return values
None

CAN1 GPIO Configuration PD0 ---—> CAN1_RX PD1 ---—> CAN1_TX

CAN2 GPIO Configuration PB13 ---—> CAN2_TX PB5 ---—> CAN2_RX

CAN3 GPIO Configuration PA8 ---—> CAN3_RX PA15 ---—> CAN3_TX

Definition at line 468 of file stm32f7xx_hal_msp.c.

469{
470 if(hcan->Instance==CAN1)
471 {
472 /* USER CODE BEGIN CAN1_MspDeInit 0 */
473
474 /* USER CODE END CAN1_MspDeInit 0 */
475 /* Peripheral clock disable */
476 HAL_RCC_CAN1_CLK_ENABLED--;
477 if(HAL_RCC_CAN1_CLK_ENABLED==0){
478 __HAL_RCC_CAN1_CLK_DISABLE();
479 }
480
485 HAL_GPIO_DeInit(GPIOD, GPIO_PIN_0|GPIO_PIN_1);
486
487 /* CAN1 interrupt DeInit */
488 HAL_NVIC_DisableIRQ(CAN1_RX0_IRQn);
489 /* USER CODE BEGIN CAN1_MspDeInit 1 */
490
491 /* USER CODE END CAN1_MspDeInit 1 */
492 }
493 else if(hcan->Instance==CAN2)
494 {
495 /* USER CODE BEGIN CAN2_MspDeInit 0 */
496
497 /* USER CODE END CAN2_MspDeInit 0 */
498 /* Peripheral clock disable */
499 __HAL_RCC_CAN2_CLK_DISABLE();
500 HAL_RCC_CAN1_CLK_ENABLED--;
501 if(HAL_RCC_CAN1_CLK_ENABLED==0){
502 __HAL_RCC_CAN1_CLK_DISABLE();
503 }
504
509 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_5);
510
511 /* CAN2 interrupt DeInit */
512 HAL_NVIC_DisableIRQ(CAN2_RX0_IRQn);
513 /* USER CODE BEGIN CAN2_MspDeInit 1 */
514
515 /* USER CODE END CAN2_MspDeInit 1 */
516 }
517 else if(hcan->Instance==CAN3)
518 {
519 /* USER CODE BEGIN CAN3_MspDeInit 0 */
520
521 /* USER CODE END CAN3_MspDeInit 0 */
522 /* Peripheral clock disable */
523 __HAL_RCC_CAN3_CLK_DISABLE();
524
529 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_8|GPIO_PIN_15);
530
531 /* USER CODE BEGIN CAN3_MspDeInit 1 */
532
533 /* USER CODE END CAN3_MspDeInit 1 */
534 }
535
536}
HAL_RCC_CAN1_CLK_ENABLED
static uint32_t HAL_RCC_CAN1_CLK_ENABLED
Definition: stm32f7xx_hal_msp.c:363

◆ HAL_CAN_MspInit()

void HAL_CAN_MspInit ( CAN_HandleTypeDef *  hcan)

CAN MSP Initialization This function configures the hardware resources used in this example.

Parameters
hcanCAN handle pointer
Return values
None

CAN1 GPIO Configuration PD0 ---—> CAN1_RX PD1 ---—> CAN1_TX

CAN2 GPIO Configuration PB13 ---—> CAN2_TX PB5 ---—> CAN2_RX

CAN3 GPIO Configuration PA8 ---—> CAN3_RX PA15 ---—> CAN3_TX

Definition at line 371 of file stm32f7xx_hal_msp.c.

372{
373 GPIO_InitTypeDef GPIO_InitStruct = {0};
374 if(hcan->Instance==CAN1)
375 {
376 /* USER CODE BEGIN CAN1_MspInit 0 */
377
378 /* USER CODE END CAN1_MspInit 0 */
379 /* Peripheral clock enable */
380 HAL_RCC_CAN1_CLK_ENABLED++;
381 if(HAL_RCC_CAN1_CLK_ENABLED==1){
382 __HAL_RCC_CAN1_CLK_ENABLE();
383 }
384
385 __HAL_RCC_GPIOD_CLK_ENABLE();
390 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
391 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
392 GPIO_InitStruct.Pull = GPIO_NOPULL;
393 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
394 GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;
395 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
396
397 /* CAN1 interrupt Init */
398 HAL_NVIC_SetPriority(CAN1_RX0_IRQn, 5, 0);
399 HAL_NVIC_EnableIRQ(CAN1_RX0_IRQn);
400 /* USER CODE BEGIN CAN1_MspInit 1 */
401
402 /* USER CODE END CAN1_MspInit 1 */
403 }
404 else if(hcan->Instance==CAN2)
405 {
406 /* USER CODE BEGIN CAN2_MspInit 0 */
407
408 /* USER CODE END CAN2_MspInit 0 */
409 /* Peripheral clock enable */
410 __HAL_RCC_CAN2_CLK_ENABLE();
411 HAL_RCC_CAN1_CLK_ENABLED++;
412 if(HAL_RCC_CAN1_CLK_ENABLED==1){
413 __HAL_RCC_CAN1_CLK_ENABLE();
414 }
415
416 __HAL_RCC_GPIOB_CLK_ENABLE();
421 GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_5;
422 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
423 GPIO_InitStruct.Pull = GPIO_NOPULL;
424 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
425 GPIO_InitStruct.Alternate = GPIO_AF9_CAN2;
426 HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
427
428 /* CAN2 interrupt Init */
429 HAL_NVIC_SetPriority(CAN2_RX0_IRQn, 5, 0);
430 HAL_NVIC_EnableIRQ(CAN2_RX0_IRQn);
431 /* USER CODE BEGIN CAN2_MspInit 1 */
432
433 /* USER CODE END CAN2_MspInit 1 */
434 }
435 else if(hcan->Instance==CAN3)
436 {
437 /* USER CODE BEGIN CAN3_MspInit 0 */
438
439 /* USER CODE END CAN3_MspInit 0 */
440 /* Peripheral clock enable */
441 __HAL_RCC_CAN3_CLK_ENABLE();
442
443 __HAL_RCC_GPIOA_CLK_ENABLE();
448 GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_15;
449 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
450 GPIO_InitStruct.Pull = GPIO_NOPULL;
451 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
452 GPIO_InitStruct.Alternate = GPIO_AF11_CAN3;
453 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
454
455 /* USER CODE BEGIN CAN3_MspInit 1 */
456
457 /* USER CODE END CAN3_MspInit 1 */
458 }
459
460}

◆ HAL_DAC_MspDeInit()

void HAL_DAC_MspDeInit ( DAC_HandleTypeDef *  hdac)

DAC MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
hdacDAC handle pointer
Return values
None

DAC GPIO Configuration PA4 ---—> DAC_OUT1 PA5 ---—> DAC_OUT2

Definition at line 615 of file stm32f7xx_hal_msp.c.

616{
617 if(hdac->Instance==DAC)
618 {
619 /* USER CODE BEGIN DAC_MspDeInit 0 */
620
621 /* USER CODE END DAC_MspDeInit 0 */
622 /* Peripheral clock disable */
623 __HAL_RCC_DAC_CLK_DISABLE();
624
629 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_4|GPIO_PIN_5);
630
631 /* DAC DMA DeInit */
632 HAL_DMA_DeInit(hdac->DMA_Handle1);
633 HAL_DMA_DeInit(hdac->DMA_Handle2);
634 /* USER CODE BEGIN DAC_MspDeInit 1 */
635
636 /* USER CODE END DAC_MspDeInit 1 */
637 }
638
639}
hdac
DAC_HandleTypeDef hdac
Definition: main.c:72

◆ HAL_DAC_MspInit()

void HAL_DAC_MspInit ( DAC_HandleTypeDef *  hdac)

DAC MSP Initialization This function configures the hardware resources used in this example.

Parameters
hdacDAC handle pointer
Return values
None

DAC GPIO Configuration PA4 ---—> DAC_OUT1 PA5 ---—> DAC_OUT2

Definition at line 544 of file stm32f7xx_hal_msp.c.

545{
546 GPIO_InitTypeDef GPIO_InitStruct = {0};
547 if(hdac->Instance==DAC)
548 {
549 /* USER CODE BEGIN DAC_MspInit 0 */
550
551 /* USER CODE END DAC_MspInit 0 */
552 /* Peripheral clock enable */
553 __HAL_RCC_DAC_CLK_ENABLE();
554
555 __HAL_RCC_GPIOA_CLK_ENABLE();
560 GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5;
561 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
562 GPIO_InitStruct.Pull = GPIO_NOPULL;
563 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
564
565 /* DAC DMA Init */
566 /* DAC1 Init */
567 hdma_dac1.Instance = DMA1_Stream5;
568 hdma_dac1.Init.Channel = DMA_CHANNEL_7;
569 hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH;
570 hdma_dac1.Init.PeriphInc = DMA_PINC_DISABLE;
571 hdma_dac1.Init.MemInc = DMA_MINC_ENABLE;
572 hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
573 hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
574 hdma_dac1.Init.Mode = DMA_CIRCULAR;
575 hdma_dac1.Init.Priority = DMA_PRIORITY_LOW;
576 hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
577 if (HAL_DMA_Init(&hdma_dac1) != HAL_OK)
578 {
579 Error_Handler();
580 }
581
582 __HAL_LINKDMA(hdac,DMA_Handle1,hdma_dac1);
583
584 /* DAC2 Init */
585 hdma_dac2.Instance = DMA1_Stream6;
586 hdma_dac2.Init.Channel = DMA_CHANNEL_7;
587 hdma_dac2.Init.Direction = DMA_MEMORY_TO_PERIPH;
588 hdma_dac2.Init.PeriphInc = DMA_PINC_DISABLE;
589 hdma_dac2.Init.MemInc = DMA_MINC_ENABLE;
590 hdma_dac2.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
591 hdma_dac2.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
592 hdma_dac2.Init.Mode = DMA_CIRCULAR;
593 hdma_dac2.Init.Priority = DMA_PRIORITY_LOW;
594 hdma_dac2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
595 if (HAL_DMA_Init(&hdma_dac2) != HAL_OK)
596 {
597 Error_Handler();
598 }
599
600 __HAL_LINKDMA(hdac,DMA_Handle2,hdma_dac2);
601
602 /* USER CODE BEGIN DAC_MspInit 1 */
603
604 /* USER CODE END DAC_MspInit 1 */
605 }
606
607}
hdma_dac1
DMA_HandleTypeDef hdma_dac1
Definition: main.c:73
hdma_dac2
DMA_HandleTypeDef hdma_dac2
Definition: main.c:74
Here is the call graph for this function:

◆ HAL_I2C_MspDeInit()

void HAL_I2C_MspDeInit ( I2C_HandleTypeDef *  hi2c)

I2C MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
hi2cI2C handle pointer
Return values
None

I2C2 GPIO Configuration PF0 ---—> I2C2_SDA PF1 ---—> I2C2_SCL

I2C4 GPIO Configuration PF14 ---—> I2C4_SCL PF15 ---—> I2C4_SDA

Definition at line 726 of file stm32f7xx_hal_msp.c.

727{
728 if(hi2c->Instance==I2C2)
729 {
730 /* USER CODE BEGIN I2C2_MspDeInit 0 */
731
732 /* USER CODE END I2C2_MspDeInit 0 */
733 /* Peripheral clock disable */
734 __HAL_RCC_I2C2_CLK_DISABLE();
735
740 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_0);
741
742 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_1);
743
744 /* USER CODE BEGIN I2C2_MspDeInit 1 */
745
746 /* USER CODE END I2C2_MspDeInit 1 */
747 }
748 else if(hi2c->Instance==I2C4)
749 {
750 /* USER CODE BEGIN I2C4_MspDeInit 0 */
751
752 /* USER CODE END I2C4_MspDeInit 0 */
753 /* Peripheral clock disable */
754 __HAL_RCC_I2C4_CLK_DISABLE();
755
760 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_14);
761
762 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_15);
763
764 /* USER CODE BEGIN I2C4_MspDeInit 1 */
765
766 /* USER CODE END I2C4_MspDeInit 1 */
767 }
768
769}

◆ HAL_I2C_MspInit()

void HAL_I2C_MspInit ( I2C_HandleTypeDef *  hi2c)

I2C MSP Initialization This function configures the hardware resources used in this example.

Parameters
hi2cI2C handle pointer
Return values
None

Initializes the peripherals clock

I2C2 GPIO Configuration PF0 ---—> I2C2_SDA PF1 ---—> I2C2_SCL

Initializes the peripherals clock

I2C4 GPIO Configuration PF14 ---—> I2C4_SCL PF15 ---—> I2C4_SDA

Definition at line 647 of file stm32f7xx_hal_msp.c.

648{
649 GPIO_InitTypeDef GPIO_InitStruct = {0};
650 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
651 if(hi2c->Instance==I2C2)
652 {
653 /* USER CODE BEGIN I2C2_MspInit 0 */
654
655 /* USER CODE END I2C2_MspInit 0 */
656
659 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2C2;
660 PeriphClkInitStruct.I2c2ClockSelection = RCC_I2C2CLKSOURCE_PCLK1;
661 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
662 {
663 Error_Handler();
664 }
665
666 __HAL_RCC_GPIOF_CLK_ENABLE();
671 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
672 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
673 GPIO_InitStruct.Pull = GPIO_NOPULL;
674 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
675 GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
676 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
677
678 /* Peripheral clock enable */
679 __HAL_RCC_I2C2_CLK_ENABLE();
680 /* USER CODE BEGIN I2C2_MspInit 1 */
681
682 /* USER CODE END I2C2_MspInit 1 */
683 }
684 else if(hi2c->Instance==I2C4)
685 {
686 /* USER CODE BEGIN I2C4_MspInit 0 */
687
688 /* USER CODE END I2C4_MspInit 0 */
689
692 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2C4;
693 PeriphClkInitStruct.I2c4ClockSelection = RCC_I2C4CLKSOURCE_PCLK1;
694 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
695 {
696 Error_Handler();
697 }
698
699 __HAL_RCC_GPIOF_CLK_ENABLE();
704 GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
705 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
706 GPIO_InitStruct.Pull = GPIO_NOPULL;
707 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
708 GPIO_InitStruct.Alternate = GPIO_AF4_I2C4;
709 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
710
711 /* Peripheral clock enable */
712 __HAL_RCC_I2C4_CLK_ENABLE();
713 /* USER CODE BEGIN I2C4_MspInit 1 */
714
715 /* USER CODE END I2C4_MspInit 1 */
716 }
717
718}
Here is the call graph for this function:

◆ HAL_MspInit()

void HAL_MspInit ( void  )

Initializes the Global MSP.

Definition at line 72 of file stm32f7xx_hal_msp.c.

73{
74
75 /* USER CODE BEGIN MspInit 0 */
76
77 /* USER CODE END MspInit 0 */
78
79 __HAL_RCC_PWR_CLK_ENABLE();
80 __HAL_RCC_SYSCFG_CLK_ENABLE();
81
82 /* System interrupt init*/
83 /* PendSV_IRQn interrupt configuration */
84 HAL_NVIC_SetPriority(PendSV_IRQn, 15, 0);
85
86 /* USER CODE BEGIN MspInit 1 */
87
88 /* USER CODE END MspInit 1 */
89}

◆ HAL_SPI_MspDeInit()

void HAL_SPI_MspDeInit ( SPI_HandleTypeDef *  hspi)

SPI MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
hspiSPI handle pointer
Return values
None

SPI4 GPIO Configuration PE2 ---—> SPI4_SCK PE5 ---—> SPI4_MISO PE6 ---—> SPI4_MOSI

SPI6 GPIO Configuration PG12 ---—> SPI6_MISO PG13 ---—> SPI6_SCK PG14 ---—> SPI6_MOSI

Definition at line 839 of file stm32f7xx_hal_msp.c.

840{
841 if(hspi->Instance==SPI4)
842 {
843 /* USER CODE BEGIN SPI4_MspDeInit 0 */
844
845 /* USER CODE END SPI4_MspDeInit 0 */
846 /* Peripheral clock disable */
847 __HAL_RCC_SPI4_CLK_DISABLE();
848
854 HAL_GPIO_DeInit(GPIOE, GPIO_PIN_2|GPIO_PIN_5|GPIO_PIN_6);
855
856 /* USER CODE BEGIN SPI4_MspDeInit 1 */
857
858 /* USER CODE END SPI4_MspDeInit 1 */
859 }
860 else if(hspi->Instance==SPI6)
861 {
862 /* USER CODE BEGIN SPI6_MspDeInit 0 */
863
864 /* USER CODE END SPI6_MspDeInit 0 */
865 /* Peripheral clock disable */
866 __HAL_RCC_SPI6_CLK_DISABLE();
867
873 HAL_GPIO_DeInit(GPIOG, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14);
874
875 /* USER CODE BEGIN SPI6_MspDeInit 1 */
876
877 /* USER CODE END SPI6_MspDeInit 1 */
878 }
879
880}

◆ HAL_SPI_MspInit()

void HAL_SPI_MspInit ( SPI_HandleTypeDef *  hspi)

SPI MSP Initialization This function configures the hardware resources used in this example.

Parameters
hspiSPI handle pointer
Return values
None

SPI4 GPIO Configuration PE2 ---—> SPI4_SCK PE5 ---—> SPI4_MISO PE6 ---—> SPI4_MOSI

SPI6 GPIO Configuration PG12 ---—> SPI6_MISO PG13 ---—> SPI6_SCK PG14 ---—> SPI6_MOSI

Definition at line 777 of file stm32f7xx_hal_msp.c.

778{
779 GPIO_InitTypeDef GPIO_InitStruct = {0};
780 if(hspi->Instance==SPI4)
781 {
782 /* USER CODE BEGIN SPI4_MspInit 0 */
783
784 /* USER CODE END SPI4_MspInit 0 */
785 /* Peripheral clock enable */
786 __HAL_RCC_SPI4_CLK_ENABLE();
787
788 __HAL_RCC_GPIOE_CLK_ENABLE();
794 GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_5|GPIO_PIN_6;
795 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
796 GPIO_InitStruct.Pull = GPIO_NOPULL;
797 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
798 GPIO_InitStruct.Alternate = GPIO_AF5_SPI4;
799 HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
800
801 /* USER CODE BEGIN SPI4_MspInit 1 */
802
803 /* USER CODE END SPI4_MspInit 1 */
804 }
805 else if(hspi->Instance==SPI6)
806 {
807 /* USER CODE BEGIN SPI6_MspInit 0 */
808
809 /* USER CODE END SPI6_MspInit 0 */
810 /* Peripheral clock enable */
811 __HAL_RCC_SPI6_CLK_ENABLE();
812
813 __HAL_RCC_GPIOG_CLK_ENABLE();
819 GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14;
820 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
821 GPIO_InitStruct.Pull = GPIO_NOPULL;
822 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
823 GPIO_InitStruct.Alternate = GPIO_AF5_SPI6;
824 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
825
826 /* USER CODE BEGIN SPI6_MspInit 1 */
827
828 /* USER CODE END SPI6_MspInit 1 */
829 }
830
831}

◆ HAL_TIM_Base_MspDeInit()

void HAL_TIM_Base_MspDeInit ( TIM_HandleTypeDef *  htim_base)

TIM_Base MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
htim_baseTIM_Base handle pointer
Return values
None

Definition at line 924 of file stm32f7xx_hal_msp.c.

925{
926 if(htim_base->Instance==TIM1)
927 {
928 /* USER CODE BEGIN TIM1_MspDeInit 0 */
929
930 /* USER CODE END TIM1_MspDeInit 0 */
931 /* Peripheral clock disable */
932 __HAL_RCC_TIM1_CLK_DISABLE();
933 /* USER CODE BEGIN TIM1_MspDeInit 1 */
934
935 /* USER CODE END TIM1_MspDeInit 1 */
936 }
937 else if(htim_base->Instance==TIM2)
938 {
939 /* USER CODE BEGIN TIM2_MspDeInit 0 */
940
941 /* USER CODE END TIM2_MspDeInit 0 */
942 /* Peripheral clock disable */
943 __HAL_RCC_TIM2_CLK_DISABLE();
944
945 /* TIM2 interrupt DeInit */
946 HAL_NVIC_DisableIRQ(TIM2_IRQn);
947 /* USER CODE BEGIN TIM2_MspDeInit 1 */
948
949 /* USER CODE END TIM2_MspDeInit 1 */
950 }
951
952}

◆ HAL_TIM_Base_MspInit()

void HAL_TIM_Base_MspInit ( TIM_HandleTypeDef *  htim_base)

TIM_Base MSP Initialization This function configures the hardware resources used in this example.

Parameters
htim_baseTIM_Base handle pointer
Return values
None

Definition at line 888 of file stm32f7xx_hal_msp.c.

889{
890 if(htim_base->Instance==TIM1)
891 {
892 /* USER CODE BEGIN TIM1_MspInit 0 */
893
894 /* USER CODE END TIM1_MspInit 0 */
895 /* Peripheral clock enable */
896 __HAL_RCC_TIM1_CLK_ENABLE();
897 /* USER CODE BEGIN TIM1_MspInit 1 */
898
899 /* USER CODE END TIM1_MspInit 1 */
900 }
901 else if(htim_base->Instance==TIM2)
902 {
903 /* USER CODE BEGIN TIM2_MspInit 0 */
904
905 /* USER CODE END TIM2_MspInit 0 */
906 /* Peripheral clock enable */
907 __HAL_RCC_TIM2_CLK_ENABLE();
908 /* TIM2 interrupt Init */
909 HAL_NVIC_SetPriority(TIM2_IRQn, 5, 0);
910 HAL_NVIC_EnableIRQ(TIM2_IRQn);
911 /* USER CODE BEGIN TIM2_MspInit 1 */
912
913 /* USER CODE END TIM2_MspInit 1 */
914 }
915
916}

◆ HAL_UART_MspDeInit()

void HAL_UART_MspDeInit ( UART_HandleTypeDef *  huart)

UART MSP De-Initialization This function freeze the hardware resources used in this example.

Parameters
huartUART handle pointer
Return values
None

USART3 GPIO Configuration PD8 ---—> USART3_TX PD9 ---—> USART3_RX

Definition at line 1007 of file stm32f7xx_hal_msp.c.

1008{
1009 if(huart->Instance==USART3)
1010 {
1011 /* USER CODE BEGIN USART3_MspDeInit 0 */
1012
1013 /* USER CODE END USART3_MspDeInit 0 */
1014 /* Peripheral clock disable */
1015 __HAL_RCC_USART3_CLK_DISABLE();
1016
1021 HAL_GPIO_DeInit(GPIOD, STLK_RX_Pin|STLK_TX_Pin);
1022
1023 /* USER CODE BEGIN USART3_MspDeInit 1 */
1024
1025 /* USER CODE END USART3_MspDeInit 1 */
1026 }
1027
1028}
STLK_RX_Pin
#define STLK_RX_Pin
Definition: main.h:68
STLK_TX_Pin
#define STLK_TX_Pin
Definition: main.h:70

◆ HAL_UART_MspInit()

void HAL_UART_MspInit ( UART_HandleTypeDef *  huart)

UART MSP Initialization This function configures the hardware resources used in this example.

Parameters
huartUART handle pointer
Return values
None

Initializes the peripherals clock

USART3 GPIO Configuration PD8 ---—> USART3_TX PD9 ---—> USART3_RX

Definition at line 960 of file stm32f7xx_hal_msp.c.

961{
962 GPIO_InitTypeDef GPIO_InitStruct = {0};
963 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
964 if(huart->Instance==USART3)
965 {
966 /* USER CODE BEGIN USART3_MspInit 0 */
967
968 /* USER CODE END USART3_MspInit 0 */
969
972 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3;
973 PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
974 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
975 {
976 Error_Handler();
977 }
978
979 /* Peripheral clock enable */
980 __HAL_RCC_USART3_CLK_ENABLE();
981
982 __HAL_RCC_GPIOD_CLK_ENABLE();
987 GPIO_InitStruct.Pin = STLK_RX_Pin|STLK_TX_Pin;
988 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
989 GPIO_InitStruct.Pull = GPIO_NOPULL;
990 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
991 GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
992 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
993
994 /* USER CODE BEGIN USART3_MspInit 1 */
995
996 /* USER CODE END USART3_MspInit 1 */
997 }
998
999}
Here is the call graph for this function:

Variable Documentation

◆ HAL_RCC_CAN1_CLK_ENABLED

uint32_t HAL_RCC_CAN1_CLK_ENABLED =0
static

Definition at line 363 of file stm32f7xx_hal_msp.c.

◆ hdma_adc1

DMA_HandleTypeDef hdma_adc1
extern

Definition at line 64 of file main.c.

◆ hdma_adc2

DMA_HandleTypeDef hdma_adc2
extern

Definition at line 69 of file AnalogSensor.h.

◆ hdma_adc3

DMA_HandleTypeDef hdma_adc3
extern

Definition at line 69 of file AnalogSensor.h.

◆ hdma_dac1

DMA_HandleTypeDef hdma_dac1
extern

Definition at line 73 of file main.c.

◆ hdma_dac2

DMA_HandleTypeDef hdma_dac2
extern

Definition at line 74 of file main.c.

Generated by doxygen 1.9.5