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 271 of file stm32f7xx_hal_msp.c.

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

◆ 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 95 of file stm32f7xx_hal_msp.c.

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

Definition at line 477 of file stm32f7xx_hal_msp.c.

478{
479 if(hcan->Instance==CAN1)
480 {
481 /* USER CODE BEGIN CAN1_MspDeInit 0 */
482
483 /* USER CODE END CAN1_MspDeInit 0 */
484 /* Peripheral clock disable */
485 HAL_RCC_CAN1_CLK_ENABLED--;
486 if(HAL_RCC_CAN1_CLK_ENABLED==0){
487 __HAL_RCC_CAN1_CLK_DISABLE();
488 }
489
494 HAL_GPIO_DeInit(GPIOD, GPIO_PIN_0|GPIO_PIN_1);
495
496 /* CAN1 interrupt DeInit */
497 HAL_NVIC_DisableIRQ(CAN1_RX0_IRQn);
498 /* USER CODE BEGIN CAN1_MspDeInit 1 */
499
500 /* USER CODE END CAN1_MspDeInit 1 */
501 }
502 else if(hcan->Instance==CAN2)
503 {
504 /* USER CODE BEGIN CAN2_MspDeInit 0 */
505
506 /* USER CODE END CAN2_MspDeInit 0 */
507 /* Peripheral clock disable */
508 __HAL_RCC_CAN2_CLK_DISABLE();
509 HAL_RCC_CAN1_CLK_ENABLED--;
510 if(HAL_RCC_CAN1_CLK_ENABLED==0){
511 __HAL_RCC_CAN1_CLK_DISABLE();
512 }
513
518 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_5);
519
520 /* CAN2 interrupt DeInit */
521 HAL_NVIC_DisableIRQ(CAN2_RX0_IRQn);
522 /* USER CODE BEGIN CAN2_MspDeInit 1 */
523
524 /* USER CODE END CAN2_MspDeInit 1 */
525 }
526 else if(hcan->Instance==CAN3)
527 {
528 /* USER CODE BEGIN CAN3_MspDeInit 0 */
529
530 /* USER CODE END CAN3_MspDeInit 0 */
531 /* Peripheral clock disable */
532 __HAL_RCC_CAN3_CLK_DISABLE();
533
538 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_15);
539
540 HAL_GPIO_DeInit(GPIOB, GPIO_PIN_3);
541
542 /* CAN3 interrupt DeInit */
543 HAL_NVIC_DisableIRQ(CAN3_RX0_IRQn);
544 /* USER CODE BEGIN CAN3_MspDeInit 1 */
545
546 /* USER CODE END CAN3_MspDeInit 1 */
547 }
548
549}
HAL_RCC_CAN1_CLK_ENABLED
static uint32_t HAL_RCC_CAN1_CLK_ENABLED
Definition: stm32f7xx_hal_msp.c:361

◆ 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 PA15 ---—> CAN3_TX PB3 ---—> CAN3_RX

Definition at line 369 of file stm32f7xx_hal_msp.c.

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

◆ 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 628 of file stm32f7xx_hal_msp.c.

629{
630 if(hdac->Instance==DAC)
631 {
632 /* USER CODE BEGIN DAC_MspDeInit 0 */
633
634 /* USER CODE END DAC_MspDeInit 0 */
635 /* Peripheral clock disable */
636 __HAL_RCC_DAC_CLK_DISABLE();
637
642 HAL_GPIO_DeInit(GPIOA, GPIO_PIN_4|GPIO_PIN_5);
643
644 /* DAC DMA DeInit */
645 HAL_DMA_DeInit(hdac->DMA_Handle1);
646 HAL_DMA_DeInit(hdac->DMA_Handle2);
647 /* USER CODE BEGIN DAC_MspDeInit 1 */
648
649 /* USER CODE END DAC_MspDeInit 1 */
650 }
651
652}
hdac
DAC_HandleTypeDef hdac
Definition: main.c:71

◆ 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 557 of file stm32f7xx_hal_msp.c.

558{
559 GPIO_InitTypeDef GPIO_InitStruct = {0};
560 if(hdac->Instance==DAC)
561 {
562 /* USER CODE BEGIN DAC_MspInit 0 */
563
564 /* USER CODE END DAC_MspInit 0 */
565 /* Peripheral clock enable */
566 __HAL_RCC_DAC_CLK_ENABLE();
567
568 __HAL_RCC_GPIOA_CLK_ENABLE();
573 GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5;
574 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
575 GPIO_InitStruct.Pull = GPIO_NOPULL;
576 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
577
578 /* DAC DMA Init */
579 /* DAC1 Init */
580 hdma_dac1.Instance = DMA1_Stream5;
581 hdma_dac1.Init.Channel = DMA_CHANNEL_7;
582 hdma_dac1.Init.Direction = DMA_MEMORY_TO_PERIPH;
583 hdma_dac1.Init.PeriphInc = DMA_PINC_DISABLE;
584 hdma_dac1.Init.MemInc = DMA_MINC_ENABLE;
585 hdma_dac1.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
586 hdma_dac1.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
587 hdma_dac1.Init.Mode = DMA_CIRCULAR;
588 hdma_dac1.Init.Priority = DMA_PRIORITY_LOW;
589 hdma_dac1.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
590 if (HAL_DMA_Init(&hdma_dac1) != HAL_OK)
591 {
592 Error_Handler();
593 }
594
595 __HAL_LINKDMA(hdac,DMA_Handle1,hdma_dac1);
596
597 /* DAC2 Init */
598 hdma_dac2.Instance = DMA1_Stream6;
599 hdma_dac2.Init.Channel = DMA_CHANNEL_7;
600 hdma_dac2.Init.Direction = DMA_MEMORY_TO_PERIPH;
601 hdma_dac2.Init.PeriphInc = DMA_PINC_DISABLE;
602 hdma_dac2.Init.MemInc = DMA_MINC_ENABLE;
603 hdma_dac2.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
604 hdma_dac2.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
605 hdma_dac2.Init.Mode = DMA_CIRCULAR;
606 hdma_dac2.Init.Priority = DMA_PRIORITY_LOW;
607 hdma_dac2.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
608 if (HAL_DMA_Init(&hdma_dac2) != HAL_OK)
609 {
610 Error_Handler();
611 }
612
613 __HAL_LINKDMA(hdac,DMA_Handle2,hdma_dac2);
614
615 /* USER CODE BEGIN DAC_MspInit 1 */
616
617 /* USER CODE END DAC_MspInit 1 */
618 }
619
620}
hdma_dac1
DMA_HandleTypeDef hdma_dac1
Definition: main.c:72
hdma_dac2
DMA_HandleTypeDef hdma_dac2
Definition: main.c:73
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 739 of file stm32f7xx_hal_msp.c.

740{
741 if(hi2c->Instance==I2C2)
742 {
743 /* USER CODE BEGIN I2C2_MspDeInit 0 */
744
745 /* USER CODE END I2C2_MspDeInit 0 */
746 /* Peripheral clock disable */
747 __HAL_RCC_I2C2_CLK_DISABLE();
748
753 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_0);
754
755 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_1);
756
757 /* USER CODE BEGIN I2C2_MspDeInit 1 */
758
759 /* USER CODE END I2C2_MspDeInit 1 */
760 }
761 else if(hi2c->Instance==I2C4)
762 {
763 /* USER CODE BEGIN I2C4_MspDeInit 0 */
764
765 /* USER CODE END I2C4_MspDeInit 0 */
766 /* Peripheral clock disable */
767 __HAL_RCC_I2C4_CLK_DISABLE();
768
773 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_14);
774
775 HAL_GPIO_DeInit(GPIOF, GPIO_PIN_15);
776
777 /* USER CODE BEGIN I2C4_MspDeInit 1 */
778
779 /* USER CODE END I2C4_MspDeInit 1 */
780 }
781
782}

◆ 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 660 of file stm32f7xx_hal_msp.c.

661{
662 GPIO_InitTypeDef GPIO_InitStruct = {0};
663 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
664 if(hi2c->Instance==I2C2)
665 {
666 /* USER CODE BEGIN I2C2_MspInit 0 */
667
668 /* USER CODE END I2C2_MspInit 0 */
669
672 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2C2;
673 PeriphClkInitStruct.I2c2ClockSelection = RCC_I2C2CLKSOURCE_PCLK1;
674 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
675 {
676 Error_Handler();
677 }
678
679 __HAL_RCC_GPIOF_CLK_ENABLE();
684 GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1;
685 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
686 GPIO_InitStruct.Pull = GPIO_NOPULL;
687 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
688 GPIO_InitStruct.Alternate = GPIO_AF4_I2C2;
689 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
690
691 /* Peripheral clock enable */
692 __HAL_RCC_I2C2_CLK_ENABLE();
693 /* USER CODE BEGIN I2C2_MspInit 1 */
694
695 /* USER CODE END I2C2_MspInit 1 */
696 }
697 else if(hi2c->Instance==I2C4)
698 {
699 /* USER CODE BEGIN I2C4_MspInit 0 */
700
701 /* USER CODE END I2C4_MspInit 0 */
702
705 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_I2C4;
706 PeriphClkInitStruct.I2c4ClockSelection = RCC_I2C4CLKSOURCE_PCLK1;
707 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
708 {
709 Error_Handler();
710 }
711
712 __HAL_RCC_GPIOF_CLK_ENABLE();
717 GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
718 GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
719 GPIO_InitStruct.Pull = GPIO_NOPULL;
720 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
721 GPIO_InitStruct.Alternate = GPIO_AF4_I2C4;
722 HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
723
724 /* Peripheral clock enable */
725 __HAL_RCC_I2C4_CLK_ENABLE();
726 /* USER CODE BEGIN I2C4_MspInit 1 */
727
728 /* USER CODE END I2C4_MspInit 1 */
729 }
730
731}
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
84 /* USER CODE BEGIN MspInit 1 */
85
86 /* USER CODE END MspInit 1 */
87}

◆ 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 852 of file stm32f7xx_hal_msp.c.

853{
854 if(hspi->Instance==SPI4)
855 {
856 /* USER CODE BEGIN SPI4_MspDeInit 0 */
857
858 /* USER CODE END SPI4_MspDeInit 0 */
859 /* Peripheral clock disable */
860 __HAL_RCC_SPI4_CLK_DISABLE();
861
867 HAL_GPIO_DeInit(GPIOE, GPIO_PIN_2|GPIO_PIN_5|GPIO_PIN_6);
868
869 /* USER CODE BEGIN SPI4_MspDeInit 1 */
870
871 /* USER CODE END SPI4_MspDeInit 1 */
872 }
873 else if(hspi->Instance==SPI6)
874 {
875 /* USER CODE BEGIN SPI6_MspDeInit 0 */
876
877 /* USER CODE END SPI6_MspDeInit 0 */
878 /* Peripheral clock disable */
879 __HAL_RCC_SPI6_CLK_DISABLE();
880
886 HAL_GPIO_DeInit(GPIOG, GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14);
887
888 /* USER CODE BEGIN SPI6_MspDeInit 1 */
889
890 /* USER CODE END SPI6_MspDeInit 1 */
891 }
892
893}

◆ 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 790 of file stm32f7xx_hal_msp.c.

791{
792 GPIO_InitTypeDef GPIO_InitStruct = {0};
793 if(hspi->Instance==SPI4)
794 {
795 /* USER CODE BEGIN SPI4_MspInit 0 */
796
797 /* USER CODE END SPI4_MspInit 0 */
798 /* Peripheral clock enable */
799 __HAL_RCC_SPI4_CLK_ENABLE();
800
801 __HAL_RCC_GPIOE_CLK_ENABLE();
807 GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_5|GPIO_PIN_6;
808 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
809 GPIO_InitStruct.Pull = GPIO_NOPULL;
810 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
811 GPIO_InitStruct.Alternate = GPIO_AF5_SPI4;
812 HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
813
814 /* USER CODE BEGIN SPI4_MspInit 1 */
815
816 /* USER CODE END SPI4_MspInit 1 */
817 }
818 else if(hspi->Instance==SPI6)
819 {
820 /* USER CODE BEGIN SPI6_MspInit 0 */
821
822 /* USER CODE END SPI6_MspInit 0 */
823 /* Peripheral clock enable */
824 __HAL_RCC_SPI6_CLK_ENABLE();
825
826 __HAL_RCC_GPIOG_CLK_ENABLE();
832 GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14;
833 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
834 GPIO_InitStruct.Pull = GPIO_NOPULL;
835 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
836 GPIO_InitStruct.Alternate = GPIO_AF5_SPI6;
837 HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
838
839 /* USER CODE BEGIN SPI6_MspInit 1 */
840
841 /* USER CODE END SPI6_MspInit 1 */
842 }
843
844}

◆ 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 937 of file stm32f7xx_hal_msp.c.

938{
939 if(htim_base->Instance==TIM1)
940 {
941 /* USER CODE BEGIN TIM1_MspDeInit 0 */
942
943 /* USER CODE END TIM1_MspDeInit 0 */
944 /* Peripheral clock disable */
945 __HAL_RCC_TIM1_CLK_DISABLE();
946 /* USER CODE BEGIN TIM1_MspDeInit 1 */
947
948 /* USER CODE END TIM1_MspDeInit 1 */
949 }
950 else if(htim_base->Instance==TIM2)
951 {
952 /* USER CODE BEGIN TIM2_MspDeInit 0 */
953
954 /* USER CODE END TIM2_MspDeInit 0 */
955 /* Peripheral clock disable */
956 __HAL_RCC_TIM2_CLK_DISABLE();
957
958 /* TIM2 interrupt DeInit */
959 HAL_NVIC_DisableIRQ(TIM2_IRQn);
960 /* USER CODE BEGIN TIM2_MspDeInit 1 */
961
962 /* USER CODE END TIM2_MspDeInit 1 */
963 }
964
965}

◆ 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 901 of file stm32f7xx_hal_msp.c.

902{
903 if(htim_base->Instance==TIM1)
904 {
905 /* USER CODE BEGIN TIM1_MspInit 0 */
906
907 /* USER CODE END TIM1_MspInit 0 */
908 /* Peripheral clock enable */
909 __HAL_RCC_TIM1_CLK_ENABLE();
910 /* USER CODE BEGIN TIM1_MspInit 1 */
911
912 /* USER CODE END TIM1_MspInit 1 */
913 }
914 else if(htim_base->Instance==TIM2)
915 {
916 /* USER CODE BEGIN TIM2_MspInit 0 */
917
918 /* USER CODE END TIM2_MspInit 0 */
919 /* Peripheral clock enable */
920 __HAL_RCC_TIM2_CLK_ENABLE();
921 /* TIM2 interrupt Init */
922 HAL_NVIC_SetPriority(TIM2_IRQn, 0, 0);
923 HAL_NVIC_EnableIRQ(TIM2_IRQn);
924 /* USER CODE BEGIN TIM2_MspInit 1 */
925
926 /* USER CODE END TIM2_MspInit 1 */
927 }
928
929}

◆ 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 1020 of file stm32f7xx_hal_msp.c.

1021{
1022 if(huart->Instance==USART3)
1023 {
1024 /* USER CODE BEGIN USART3_MspDeInit 0 */
1025
1026 /* USER CODE END USART3_MspDeInit 0 */
1027 /* Peripheral clock disable */
1028 __HAL_RCC_USART3_CLK_DISABLE();
1029
1034 HAL_GPIO_DeInit(GPIOD, STLK_RX_Pin|STLK_TX_Pin);
1035
1036 /* USER CODE BEGIN USART3_MspDeInit 1 */
1037
1038 /* USER CODE END USART3_MspDeInit 1 */
1039 }
1040
1041}
STLK_RX_Pin
#define STLK_RX_Pin
Definition: main.h:70
STLK_TX_Pin
#define STLK_TX_Pin
Definition: main.h:72

◆ 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 973 of file stm32f7xx_hal_msp.c.

974{
975 GPIO_InitTypeDef GPIO_InitStruct = {0};
976 RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
977 if(huart->Instance==USART3)
978 {
979 /* USER CODE BEGIN USART3_MspInit 0 */
980
981 /* USER CODE END USART3_MspInit 0 */
982
985 PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART3;
986 PeriphClkInitStruct.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
987 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
988 {
989 Error_Handler();
990 }
991
992 /* Peripheral clock enable */
993 __HAL_RCC_USART3_CLK_ENABLE();
994
995 __HAL_RCC_GPIOD_CLK_ENABLE();
1000 GPIO_InitStruct.Pin = STLK_RX_Pin|STLK_TX_Pin;
1001 GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
1002 GPIO_InitStruct.Pull = GPIO_NOPULL;
1003 GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
1004 GPIO_InitStruct.Alternate = GPIO_AF7_USART3;
1005 HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
1006
1007 /* USER CODE BEGIN USART3_MspInit 1 */
1008
1009 /* USER CODE END USART3_MspInit 1 */
1010 }
1011
1012}
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 361 of file stm32f7xx_hal_msp.c.

◆ hdma_adc1

DMA_HandleTypeDef hdma_adc1
extern

Definition at line 63 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 72 of file main.c.

◆ hdma_dac2

DMA_HandleTypeDef hdma_dac2
extern

Definition at line 73 of file main.c.

Generated by doxygen 1.9.5