main.c File Reference

: Main program body More...

#include "main.h"
#include "cmsis_os.h"
#include "../Inc/Files/can1_dbc.h"
#include "../Inc/Scheduler/Scheduler.h"
#include "../Inc/Sensors/AnalogSensor.h"
#include "../Inc/Systems/Comms/Can/Can.h"
#include "../Inc/Systems/Controller/Apps.h"
#include "../Inc/Systems/Controller/BrakeSystemControl.h"
#include "../Inc/Systems/Controller/RTD.h"
#include "../Inc/Systems/Controller/TorqueControl.h"
#include "../Inc/Systems/External/Inverter.h"
#include "../Inc/Systems/Monitor/AppsMonitor.h"
#include "../Inc/Systems/Monitor/BrakePolice.h"
#include "../Inc/Systems/Monitor/RTDMonitor.h"
#include "../Inc/Systems/Monitor/TorquePolice.h"
#include "../Inc/Utils/Constants.h"
#include "../Inc/Utils/Telemetry.h"
#include "stm32f7xx_hal_adc.h"
#include "stm32f7xx_it.h"

Include dependency graph for main.c:

Go to the source code of this file.

Functions
void	SystemClock_Config (void)
	System Clock Configuration. More...
static void	MX_GPIO_Init (void)
	GPIO Initialization Function. More...
static void	MX_DMA_Init (void)
static void	MX_TIM1_Init (void)
	TIM1 Initialization Function. More...
static void	MX_ADC1_Init (void)
	ADC1 Initialization Function. More...
static void	MX_ADC2_Init (void)
	ADC2 Initialization Function. More...
static void	MX_ADC3_Init (void)
	ADC3 Initialization Function. More...
static void	MX_CAN1_Init (void)
	CAN1 Initialization Function. More...
static void	MX_CAN2_Init (void)
	CAN2 Initialization Function. More...
static void	MX_USART3_UART_Init (void)
	USART3 Initialization Function. More...
static void	MX_TIM2_Init (void)
	TIM2 Initialization Function. More...
static void	MX_DAC_Init (void)
	DAC Initialization Function. More...
static void	MX_CAN3_Init (void)
	CAN3 Initialization Function. More...
static void	MX_I2C2_Init (void)
	I2C2 Initialization Function. More...
static void	MX_I2C4_Init (void)
	I2C4 Initialization Function. More...
static void	MX_SPI4_Init (void)
	SPI4 Initialization Function. More...
static void	MX_SPI6_Init (void)
	SPI6 Initialization Function. More...
void	StartDefaultTask (void *argument)
	Function implementing the defaultTask thread. More...
int	main (void)
	The application entry point. More...
int	_write (int file, char *data, int len)
void	vApplicationMallocFailedHook (void)
void	vApplicationIdleHook (void)
void	vApplicationStackOverflowHook (TaskHandle_t xTask, char *pcTaskName)
void	vApplicationTickHook (void)
void	Error_Handler (void)
	This function is executed in case of error occurrence. More...

Variables
ADC_HandleTypeDef	hadc1
ADC_HandleTypeDef	hadc2
ADC_HandleTypeDef	hadc3
DMA_HandleTypeDef	hdma_adc1
DMA_HandleTypeDef	hdma_adc2
DMA_HandleTypeDef	hdma_adc3
CAN_HandleTypeDef	hcan1
CAN_HandleTypeDef	hcan2
CAN_HandleTypeDef	hcan3
DAC_HandleTypeDef	hdac
DMA_HandleTypeDef	hdma_dac1
DMA_HandleTypeDef	hdma_dac2
I2C_HandleTypeDef	hi2c2
I2C_HandleTypeDef	hi2c4
SPI_HandleTypeDef	hspi4
SPI_HandleTypeDef	hspi6
TIM_HandleTypeDef	htim1
TIM_HandleTypeDef	htim2
UART_HandleTypeDef	huart3
osThreadId_t	defaultTaskHandle
const osThreadAttr_t	defaultTask_attributes
uint32_t	adc1_buffer [ADC1_CHANNEL_SIZE]
uint32_t	adc2_buffer [ADC2_CHANNEL_SIZE]
uint32_t	adc3_buffer [ADC3_CHANNEL_SIZE]
uint32_t	dac1_buffer [DAC1_BUFFER_SIZE]
uint32_t	dac2_buffer [DAC2_BUFFER_SIZE]
uint8_t	digital_out_buffer [NUM_DIGITAL_OUTPUTS]
uint8_t	digital_in_buffer [NUM_DIGITAL_INPUTS]

Detailed Description

: Main program body

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 main.c.

Function Documentation

_write()

int _write	(	int	file,
		char *	data,
		int	len
	)

Definition at line 1476 of file main.c.

{
    // Transmit data using USART3
    HAL_UART_Transmit(&huart3, (uint8_t *)data, len, HAL_MAX_DELAY);
    return len;
 
#endif // <--- DONT DELETE THIS, IT IS LINKED TO LAST LINE IN MAIN FUNCTION TO ALLOW SIL BUILDS
 
}

Error_Handler()

void Error_Handler

(

void

)

This function is executed in case of error occurrence.

Return values

None

Definition at line 1530 of file main.c.

{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  
  #ifndef TEST_MODE
  __disable_irq();
  #endif
 
  while (1)
  {
    //printf("Error_Handler\r\n");
  }
  /* USER CODE END Error_Handler_Debug */
}

Here is the caller graph for this function:

main()

int main

(

void

)

The application entry point.

Return values

int

Definition at line 139 of file main.c.

{
 
  /* USER CODE BEGIN 1 */
 
  #ifndef TEST_MODE
 
  /* USER CODE END 1 */
 
  /* MCU Configuration--------------------------------------------------------*/
 
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();
 
  /* USER CODE BEGIN Init */
 
  /* USER CODE END Init */
 
  /* Configure the system clock */
  SystemClock_Config();
 
  /* USER CODE BEGIN SysInit */
 
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_TIM1_Init();
  MX_ADC1_Init();
  MX_ADC2_Init();
  MX_ADC3_Init();
  MX_CAN1_Init();
  MX_CAN2_Init();
  MX_USART3_UART_Init();
  MX_TIM2_Init();
  MX_DAC_Init();
  MX_CAN3_Init();
  MX_I2C2_Init();
  MX_I2C4_Init();
  MX_SPI4_Init();
  MX_SPI6_Init();
  /* USER CODE BEGIN 2 */
 
  // Clear the screen
  // //printf("\033[2J\033[1;1H");
  // //printf("Welcome to VCU!!!\r\n");
  if (init_CANBus(CAN_1) != 0) {
    // //printf("CAN1 init failed\r\n");
  }
 
  // Init Telemetry
  initTelemetry();
 
  // Begin ADC DMA
  if(HAL_ADC_Start_DMA(&hadc1, (uint32_t*)adc1_buffer, 7) != HAL_OK) {
      Error_Handler();
  }
 
  if(HAL_ADC_Start_DMA(&hadc2, (uint32_t*)adc2_buffer, 7) != HAL_OK) {
    Error_Handler();
  }
 
  if(HAL_ADC_Start_DMA(&hadc3, (uint32_t*)adc3_buffer, 8) != HAL_OK) {
    Error_Handler();
  }
 
  // Begin DAC DMA
  if(HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1, (uint32_t*)dac1_buffer, DAC1_BUFFER_SIZE, DAC_ALIGN_12B_R) != HAL_OK) {
    Error_Handler();
  }
 
  __HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);
  initUartConfigListener();
 
  uint32_t multi_mode = (ADC123_COMMON->CCR & ADC_CCR_MULTI);
  //printf("ADC Multi-mode: 0x%08lX\r\n", multi_mode);
 
  #endif
 
  // Add a message to the CAN message list
  CAN_Signal_Template signals[8] = {
    { .name = "VDD", .start_bit = 0, .length = 8, .endian = 0, .isSigned = 0, .scale = 0.1, .offset = 0, .min = 0, .max = 255, .unit = "voltage", .reciever = "reciever" },
    { .name = "Char 2", .start_bit = 8, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 3", .start_bit = 16, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 4", .start_bit = 24, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 5", .start_bit = 32, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 6", .start_bit = 40, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 7", .start_bit = 48, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" },
    { .name = "Char 8", .start_bit = 56, .length = 8, .endian = 0, .isSigned = 0, .scale = 1, .offset = 0, .min = 0, .max = 255, .unit = "unit", .reciever = "reciever" }
  };
 
  add_message_lop(CAN_1, 0x123, 8, 0, 0, "Message 1", "AD3", 8, signals);
 
 
  add_message_lop(CAN_1, 0x124, 8, 0, 0, "Message 2", "VCU", 8, signals);
 
  // Print the CAN message list
  print_CAN_Messages_Lists();
 
  uint8_t txdata[8] = {0, 1, 2, 3, 4, 5, 6, 7};
  send_CAN_message(CAN_1, CAN_2A, 124, txdata, 8);
 
  // Make Apps Controller and Monitor
  Apps apps;
  initApps(&apps, 10, 8, 4);
 
  AppsMonitor am;
  initAppsMonitor(&am, &apps, 10);
 
  // Bind Appsmonitor to Apps
  apps.base.addMonitor(&apps, &am);
 
  // Start the Apps Monitor
  startAppsMonitor(&am);
 
  // Make Break Controller and Monitor
  BrakeSystemControl bsc;
  initBrakeSystemControl(&bsc, 10, 200, 400, 1000, 10, 5, 6, 0);
 
  BrakePolice bp;
  initBrakePolice(&bp, &bsc, 100, 200);
 
  // Bind BrakePolice to BrakeSystemControl
  bsc.base.addMonitor(&bsc, &bp);
 
  // Start the Brake Controller and Monitor
  startBrakeSystemControl(&bsc);
  startBrakePolice(&bp);
 
  // Make RTD Controller and Monitor
  RTD rtd;
  initRTD(&rtd, &apps, &bsc, 10, 0, 1);
 
  RTDMonitor rm;
  initRTDMonitor(&rm, &rtd, 10);
 
  // Bind RTDMonitor to RTD
  rtd.base.addMonitor(&rtd, &rm);
 
  // Start the RTD Controller and Monitor
  startRTD(&rtd);
  startRTDMonitor(&rm);
 
  // Make Torque Controller and Monitor
  TorqueControl tc;
  initTorqueControl(&tc, &apps, 10, 240);
 
  TorquePolice tp;
  initTorquePolice(&tp, &tc, &bsc, &rtd, 100, 240);
 
  // Bind TorquePolice to TorqueControl
  tc.base.addMonitor(&tc, &tp);
 
  // Start the Torque Controller and Monitor
  startTorqueControl(&tc);
  startTorquePolice(&tp);
 
  // Make Inverter
  Inverter inverter;
  initInverter(&inverter, &tc, 10, 200, 100, 400);
 
  // Make Scheduler from updateable array
  Scheduler scheduler;
 
  Updateable* updateables[6];
  updateables[0] = &apps.base.system.updateable;
  updateables[1] = &bsc.base.system.updateable;
  updateables[2] = &rtd.base.system.updateable;
  updateables[3] = &tc.base.system.updateable;
  updateables[4] = &inverter.base.system.updateable;
  updateables[5] = NULL;
 
  SchedulerInit(&scheduler, updateables);
 
  //printf("Starting Vehicle Control Unit with FreeRTOS scheduler...\n");
 
  // Start the Scheduler
  SchedulerRun(&scheduler);
  /* USER CODE END 2 */
 
  /* Init scheduler */
  osKernelInitialize();
 
  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */
 
  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */
 
  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */
 
  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */
 
  /* Create the thread(s) */
  /* creation of defaultTask */
  defaultTaskHandle = osThreadNew(StartDefaultTask, NULL, &defaultTask_attributes);
 
  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */
 
  /* USER CODE BEGIN RTOS_EVENTS */
  /* add events, ... */
  /* USER CODE END RTOS_EVENTS */
 
  /* Start scheduler */
  osKernelStart();
 
  /* We should never get here as control is now taken by the scheduler */
 
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  static uint32_t test_can_counter = 0;
  while (1)
  {
    //printf("ERROR: Scheduler returned unexpectedly!\n");
    
    // Send test CAN message every 5 seconds
    test_can_counter++;
    if (test_can_counter >= 5) {
      test_can_counter = 0;
      
      // Send test CAN message with incrementing data
      uint8_t test_data[8] = {0xAA, 0xBB, 0xCC, 0xDD, (uint8_t)(HAL_GetTick() & 0xFF), 0x55, 0x66, 0x77};
      send_CAN_message(CAN_1, CAN_2A, 0x123, test_data, 8);
      
      // Send another test message with different ID
      uint8_t test_data2[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (uint8_t)((HAL_GetTick() >> 8) & 0xFF)};
      send_CAN_message(CAN_1, CAN_2A, 0x456, test_data2, 8);
    }
    
    HAL_Delay(1000);
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  #ifndef TEST_MODE
  /* USER CODE END 3 */
}

Here is the call graph for this function:

MX_ADC1_Init()

static void MX_ADC1_Init ( void  )

static

ADC1 Initialization Function.

Parameters

None

Return values

None

Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Definition at line 441 of file main.c.

{
 
  /* USER CODE BEGIN ADC1_Init 0 */
 
  /* USER CODE END ADC1_Init 0 */
 
  ADC_ChannelConfTypeDef sConfig = {0};
 
  /* USER CODE BEGIN ADC1_Init 1 */
 
  /* USER CODE END ADC1_Init 1 */
 
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.NbrOfConversion = 7;
  hadc1.Init.DMAContinuousRequests = ENABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_2;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_8;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_10;
  sConfig.Rank = ADC_REGULAR_RANK_5;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_12;
  sConfig.Rank = ADC_REGULAR_RANK_6;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Rank = ADC_REGULAR_RANK_7;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */
 
  /* USER CODE END ADC1_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_ADC2_Init()

static void MX_ADC2_Init ( void  )

static

ADC2 Initialization Function.

Parameters

None

Return values

None

Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Definition at line 546 of file main.c.

{
 
  /* USER CODE BEGIN ADC2_Init 0 */
 
  /* USER CODE END ADC2_Init 0 */
 
  ADC_ChannelConfTypeDef sConfig = {0};
 
  /* USER CODE BEGIN ADC2_Init 1 */
 
  /* USER CODE END ADC2_Init 1 */
 
  hadc2.Instance = ADC2;
  hadc2.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc2.Init.Resolution = ADC_RESOLUTION_12B;
  hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc2.Init.ContinuousConvMode = DISABLE;
  hadc2.Init.DiscontinuousConvMode = DISABLE;
  hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc2.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc2.Init.NbrOfConversion = 7;
  hadc2.Init.DMAContinuousRequests = ENABLE;
  hadc2.Init.EOCSelection = ADC_EOC_SEQ_CONV;
  if (HAL_ADC_Init(&hadc2) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_1;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_3;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_7;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_9;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_11;
  sConfig.Rank = ADC_REGULAR_RANK_5;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_13;
  sConfig.Rank = ADC_REGULAR_RANK_6;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_15;
  sConfig.Rank = ADC_REGULAR_RANK_7;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC2_Init 2 */
 
  /* USER CODE END ADC2_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_ADC3_Init()

static void MX_ADC3_Init ( void  )

static

ADC3 Initialization Function.

Parameters

None

Return values

None

Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.

Definition at line 652 of file main.c.

{
 
  /* USER CODE BEGIN ADC3_Init 0 */
 
  /* USER CODE END ADC3_Init 0 */
 
  ADC_ChannelConfTypeDef sConfig = {0};
 
  /* USER CODE BEGIN ADC3_Init 1 */
 
  /* USER CODE END ADC3_Init 1 */
 
  hadc3.Instance = ADC3;
  hadc3.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
  hadc3.Init.Resolution = ADC_RESOLUTION_12B;
  hadc3.Init.ScanConvMode = ADC_SCAN_ENABLE;
  hadc3.Init.ContinuousConvMode = DISABLE;
  hadc3.Init.DiscontinuousConvMode = DISABLE;
  hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_RISING;
  hadc3.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T2_TRGO;
  hadc3.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc3.Init.NbrOfConversion = 8;
  hadc3.Init.DMAContinuousRequests = ENABLE;
  hadc3.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  if (HAL_ADC_Init(&hadc3) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_4;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_5;
  sConfig.Rank = ADC_REGULAR_RANK_2;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_3;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_7;
  sConfig.Rank = ADC_REGULAR_RANK_4;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_8;
  sConfig.Rank = ADC_REGULAR_RANK_5;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_9;
  sConfig.Rank = ADC_REGULAR_RANK_6;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_14;
  sConfig.Rank = ADC_REGULAR_RANK_7;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_15;
  sConfig.Rank = ADC_REGULAR_RANK_8;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC3_Init 2 */
 
  /* USER CODE END ADC3_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_CAN1_Init()

static void MX_CAN1_Init ( void  )

static

CAN1 Initialization Function.

Parameters

None

Return values

None

Definition at line 767 of file main.c.

{
 
  /* USER CODE BEGIN CAN1_Init 0 */
 
  /* USER CODE END CAN1_Init 0 */
 
  /* USER CODE BEGIN CAN1_Init 1 */
 
  /* USER CODE END CAN1_Init 1 */
  hcan1.Instance = CAN1;
  hcan1.Init.Prescaler = 3;
  hcan1.Init.Mode = CAN_MODE_NORMAL;
  hcan1.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan1.Init.TimeSeg1 = CAN_BS1_13TQ;
  hcan1.Init.TimeSeg2 = CAN_BS2_2TQ;
  hcan1.Init.TimeTriggeredMode = DISABLE;
  hcan1.Init.AutoBusOff = DISABLE;
  hcan1.Init.AutoWakeUp = DISABLE;
  hcan1.Init.AutoRetransmission = DISABLE;
  hcan1.Init.ReceiveFifoLocked = DISABLE;
  hcan1.Init.TransmitFifoPriority = DISABLE;
  if (HAL_CAN_Init(&hcan1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN1_Init 2 */
  CAN_FilterTypeDef sFilterConfig;
  sFilterConfig.FilterBank = 0;
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
  sFilterConfig.FilterIdHigh = 0x0000;
  sFilterConfig.FilterIdLow = 0x0000;
  sFilterConfig.FilterMaskIdHigh = 0x0000;
  sFilterConfig.FilterMaskIdLow = 0x0000;
  sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
  sFilterConfig.FilterActivation = ENABLE;
  sFilterConfig.SlaveStartFilterBank = 14;
  HAL_CAN_ConfigFilter(&hcan1, &sFilterConfig);
 
  // Stop CAN
  HAL_CAN_Stop(&hcan1);
  // Start CAN
  if (HAL_CAN_Start(&hcan1) != HAL_OK) {
      //printf("CAN1 Start Error: ErrorCode = 0x%lX\r\n", hcan1.ErrorCode);
  }
 
  // Start IRQ for CAN Rx
  if (HAL_CAN_ActivateNotification(&hcan1, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK) {
    //printf("interrupt CAN1 init failed\r\n");
  }
  
  // Enable TX completion interrupts for telemetry
  if (HAL_CAN_ActivateNotification(&hcan1, CAN_IT_TX_MAILBOX_EMPTY) != HAL_OK) {
    //printf("CAN1 TX interrupt init failed\r\n");
  }
  /* USER CODE END CAN1_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_CAN2_Init()

static void MX_CAN2_Init ( void  )

static

CAN2 Initialization Function.

Parameters

None

Return values

None

Definition at line 832 of file main.c.

{
 
  /* USER CODE BEGIN CAN2_Init 0 */
 
  /* USER CODE END CAN2_Init 0 */
 
  /* USER CODE BEGIN CAN2_Init 1 */
 
  /* USER CODE END CAN2_Init 1 */
  hcan2.Instance = CAN2;
  hcan2.Init.Prescaler = 4;
  hcan2.Init.Mode = CAN_MODE_NORMAL;
  hcan2.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan2.Init.TimeSeg1 = CAN_BS1_10TQ;
  hcan2.Init.TimeSeg2 = CAN_BS2_1TQ;
  hcan2.Init.TimeTriggeredMode = DISABLE;
  hcan2.Init.AutoBusOff = DISABLE;
  hcan2.Init.AutoWakeUp = DISABLE;
  hcan2.Init.AutoRetransmission = DISABLE;
  hcan2.Init.ReceiveFifoLocked = DISABLE;
  hcan2.Init.TransmitFifoPriority = DISABLE;
  if (HAL_CAN_Init(&hcan2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN2_Init 2 */
  CAN_FilterTypeDef sFilterConfig;
  sFilterConfig.FilterBank = 0;
  sFilterConfig.FilterMode = CAN_FILTERMODE_IDMASK;
  sFilterConfig.FilterScale = CAN_FILTERSCALE_32BIT;
  sFilterConfig.FilterIdHigh = 0x0000;
  sFilterConfig.FilterIdLow = 0x0000;
  sFilterConfig.FilterMaskIdHigh = 0x0000;
  sFilterConfig.FilterMaskIdLow = 0x0000;
  sFilterConfig.FilterFIFOAssignment = CAN_RX_FIFO0;
  sFilterConfig.FilterActivation = ENABLE;
  sFilterConfig.SlaveStartFilterBank = 14;
  HAL_CAN_ConfigFilter(&hcan2, &sFilterConfig);
 
  // Stop CAN
  HAL_CAN_Stop(&hcan2);
  // Start CAN
  if (HAL_CAN_Start(&hcan2) != HAL_OK) {
      //printf("CAN2 Start Error: ErrorCode = 0x%lX\r\n", hcan2.ErrorCode);
  }
 
  // Start IRQ for CAN Rx
  if (HAL_CAN_ActivateNotification(&hcan2, CAN_IT_RX_FIFO0_MSG_PENDING) != HAL_OK) {
    //printf("interrupt CAN2 init failed\r\n");
  }
  
  // Enable TX completion interrupts for telemetry
  if (HAL_CAN_ActivateNotification(&hcan2, CAN_IT_TX_MAILBOX_EMPTY) != HAL_OK) {
    //printf("CAN2 TX interrupt init failed\r\n");
  }
  /* USER CODE END CAN2_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_CAN3_Init()

static void MX_CAN3_Init ( void  )

static

CAN3 Initialization Function.

Parameters

None

Return values

None

Definition at line 897 of file main.c.

{
 
  /* USER CODE BEGIN CAN3_Init 0 */
 
  /* USER CODE END CAN3_Init 0 */
 
  /* USER CODE BEGIN CAN3_Init 1 */
 
  /* USER CODE END CAN3_Init 1 */
  hcan3.Instance = CAN3;
  hcan3.Init.Prescaler = 16;
  hcan3.Init.Mode = CAN_MODE_NORMAL;
  hcan3.Init.SyncJumpWidth = CAN_SJW_1TQ;
  hcan3.Init.TimeSeg1 = CAN_BS1_1TQ;
  hcan3.Init.TimeSeg2 = CAN_BS2_1TQ;
  hcan3.Init.TimeTriggeredMode = DISABLE;
  hcan3.Init.AutoBusOff = DISABLE;
  hcan3.Init.AutoWakeUp = DISABLE;
  hcan3.Init.AutoRetransmission = DISABLE;
  hcan3.Init.ReceiveFifoLocked = DISABLE;
  hcan3.Init.TransmitFifoPriority = DISABLE;
  if (HAL_CAN_Init(&hcan3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN CAN3_Init 2 */
 
  /* USER CODE END CAN3_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_DAC_Init()

static void MX_DAC_Init ( void  )

static

DAC Initialization Function.

Parameters

None

Return values

None

DAC Initialization

DAC channel OUT1 config

DAC channel OUT2 config

Definition at line 934 of file main.c.

{
 
  /* USER CODE BEGIN DAC_Init 0 */
 
  /* USER CODE END DAC_Init 0 */
 
  DAC_ChannelConfTypeDef sConfig = {0};
 
  /* USER CODE BEGIN DAC_Init 1 */
 
  /* USER CODE END DAC_Init 1 */
 
  hdac.Instance = DAC;
  if (HAL_DAC_Init(&hdac) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.DAC_Trigger = DAC_TRIGGER_T2_TRGO;
  sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
  if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN DAC_Init 2 */
 
  /* USER CODE END DAC_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_DMA_Init()

static void MX_DMA_Init ( void  )

static

Enable DMA controller clock

Definition at line 1284 of file main.c.

{
 
  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();
  __HAL_RCC_DMA1_CLK_ENABLE();
 
  /* DMA interrupt init */
  /* 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);
  /* 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);
 
}

Here is the caller graph for this function:

MX_GPIO_Init()

static void MX_GPIO_Init ( void  )

static

GPIO Initialization Function.

Parameters

None

Return values

None

Definition at line 1315 of file main.c.

{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
 
  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOF, GPIO_PIN_12|GPIO_PIN_13, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_11
                          |GPIO_PIN_13, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_14|GPIO_PIN_15, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOG, GPIO_PIN_9, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(LD2_GPIO_Port, LD2_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pins : PE3 PE4 PE10 PE12
                           PE14 PE15 PE0 PE1 */
  GPIO_InitStruct.Pin = GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_10|GPIO_PIN_12
                          |GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_0|GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
  /*Configure GPIO pin : USER_Btn_Pin */
  GPIO_InitStruct.Pin = USER_Btn_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(USER_Btn_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PF2 PF11 */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PB2 PB10 PB11 PB12
                           PB14 PB15 PB4 PB6 */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12
                          |GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_4|GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PF12 PF13 */
  GPIO_InitStruct.Pin = GPIO_PIN_12|GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PG0 PG1 PG2 PG3
                           PG4 PG5 PG6 PG8
                           PG10 PG11 PG15 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_8
                          |GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PE7 PE8 PE9 PE11
                           PE13 */
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_11
                          |GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PD10 PD11 PD12 PD13
                           PD3 PD4 PD5 PD6
                           PD7 */
  GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13
                          |GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6
                          |GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PD14 PD15 */
  GPIO_InitStruct.Pin = GPIO_PIN_14|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
  /*Configure GPIO pin : USB_OverCurrent_Pin */
  GPIO_InitStruct.Pin = USB_OverCurrent_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(USB_OverCurrent_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PC6 PC7 PC8 PC9
                           PC10 PC11 PC12 */
  GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9
                          |GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_SDMMC1;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PA9 PA10 PA11 PA12 */
  GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PD2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_SDMMC1;
  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
 
  /*Configure GPIO pin : PG9 */
  GPIO_InitStruct.Pin = GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
 
  /*Configure GPIO pin : LD2_Pin */
  GPIO_InitStruct.Pin = LD2_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(LD2_GPIO_Port, &GPIO_InitStruct);
 
  /*Configure GPIO pins : PB8 PB9 */
  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_AF12_SDMMC1;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}

Here is the caller graph for this function:

MX_I2C2_Init()

static void MX_I2C2_Init ( void  )

static

I2C2 Initialization Function.

Parameters

None

Return values

None

Configure Analogue filter

Configure Digital filter

Definition at line 981 of file main.c.

{
 
  /* USER CODE BEGIN I2C2_Init 0 */
 
  /* USER CODE END I2C2_Init 0 */
 
  /* USER CODE BEGIN I2C2_Init 1 */
 
  /* USER CODE END I2C2_Init 1 */
  hi2c2.Instance = I2C2;
  hi2c2.Init.Timing = 0x00506682;
  hi2c2.Init.OwnAddress1 = 0;
  hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c2.Init.OwnAddress2 = 0;
  hi2c2.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c2) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c2, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c2, 0) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C2_Init 2 */
 
  /* USER CODE END I2C2_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_I2C4_Init()

static void MX_I2C4_Init ( void  )

static

I2C4 Initialization Function.

Parameters

None

Return values

None

Configure Analogue filter

Configure Digital filter

Definition at line 1029 of file main.c.

{
 
  /* USER CODE BEGIN I2C4_Init 0 */
 
  /* USER CODE END I2C4_Init 0 */
 
  /* USER CODE BEGIN I2C4_Init 1 */
 
  /* USER CODE END I2C4_Init 1 */
  hi2c4.Instance = I2C4;
  hi2c4.Init.Timing = 0x00506682;
  hi2c4.Init.OwnAddress1 = 0;
  hi2c4.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c4.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c4.Init.OwnAddress2 = 0;
  hi2c4.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c4.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c4.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c4) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c4, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }
 
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c4, 0) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN I2C4_Init 2 */
 
  /* USER CODE END I2C4_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_SPI4_Init()

static void MX_SPI4_Init ( void  )

static

SPI4 Initialization Function.

Parameters

None

Return values

None

Definition at line 1077 of file main.c.

{
 
  /* USER CODE BEGIN SPI4_Init 0 */
 
  /* USER CODE END SPI4_Init 0 */
 
  /* USER CODE BEGIN SPI4_Init 1 */
 
  /* USER CODE END SPI4_Init 1 */
  /* SPI4 parameter configuration*/
  hspi4.Instance = SPI4;
  hspi4.Init.Mode = SPI_MODE_MASTER;
  hspi4.Init.Direction = SPI_DIRECTION_2LINES;
  hspi4.Init.DataSize = SPI_DATASIZE_4BIT;
  hspi4.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi4.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi4.Init.NSS = SPI_NSS_SOFT;
  hspi4.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi4.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi4.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi4.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi4.Init.CRCPolynomial = 7;
  hspi4.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi4.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  if (HAL_SPI_Init(&hspi4) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI4_Init 2 */
 
  /* USER CODE END SPI4_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_SPI6_Init()

static void MX_SPI6_Init ( void  )

static

SPI6 Initialization Function.

Parameters

None

Return values

None

Definition at line 1117 of file main.c.

{
 
  /* USER CODE BEGIN SPI6_Init 0 */
 
  /* USER CODE END SPI6_Init 0 */
 
  /* USER CODE BEGIN SPI6_Init 1 */
 
  /* USER CODE END SPI6_Init 1 */
  /* SPI6 parameter configuration*/
  hspi6.Instance = SPI6;
  hspi6.Init.Mode = SPI_MODE_MASTER;
  hspi6.Init.Direction = SPI_DIRECTION_2LINES;
  hspi6.Init.DataSize = SPI_DATASIZE_4BIT;
  hspi6.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi6.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi6.Init.NSS = SPI_NSS_SOFT;
  hspi6.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi6.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi6.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi6.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi6.Init.CRCPolynomial = 7;
  hspi6.Init.CRCLength = SPI_CRC_LENGTH_DATASIZE;
  hspi6.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  if (HAL_SPI_Init(&hspi6) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI6_Init 2 */
 
  /* USER CODE END SPI6_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM1_Init()

static void MX_TIM1_Init ( void  )

static

TIM1 Initialization Function.

Parameters

None

Return values

None

Definition at line 1157 of file main.c.

{
 
  /* USER CODE BEGIN TIM1_Init 0 */
 
  /* USER CODE END TIM1_Init 0 */
 
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
 
  /* USER CODE BEGIN TIM1_Init 1 */
 
  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 47999;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 999;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */
 
  /* USER CODE END TIM1_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM2_Init()

static void MX_TIM2_Init ( void  )

static

TIM2 Initialization Function.

Parameters

None

Return values

None

Definition at line 1204 of file main.c.

{
 
  /* USER CODE BEGIN TIM2_Init 0 */
 
  /* USER CODE END TIM2_Init 0 */
 
  TIM_ClockConfigTypeDef sClockSourceConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};
 
  /* USER CODE BEGIN TIM2_Init 1 */
 
  /* USER CODE END TIM2_Init 1 */
  htim2.Instance = TIM2;
  htim2.Init.Prescaler = 0;
  htim2.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim2.Init.Period = 479999;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
  if (HAL_TIM_ConfigClockSource(&htim2, &sClockSourceConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_UPDATE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */
  if (HAL_TIM_Base_Start_IT(&htim2) != HAL_OK) {
      Error_Handler();
  }
  /* USER CODE END TIM2_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_USART3_UART_Init()

static void MX_USART3_UART_Init ( void  )

static

USART3 Initialization Function.

Parameters

None

Return values

None

Definition at line 1251 of file main.c.

{
 
  /* USER CODE BEGIN USART3_Init 0 */
 
  /* USER CODE END USART3_Init 0 */
 
  /* USER CODE BEGIN USART3_Init 1 */
 
  /* USER CODE END USART3_Init 1 */
  huart3.Instance = USART3;
  huart3.Init.BaudRate = 115200;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */
 
  /* USER CODE END USART3_Init 2 */
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartDefaultTask()

void StartDefaultTask

(

void *

argument

)

Function implementing the defaultTask thread.

Parameters

argument

Not used

Return values

None

Definition at line 1515 of file main.c.

{
  /* USER CODE BEGIN 5 */
  /* Infinite loop */
  for(;;)
  {
    osDelay(1);
  }
  /* USER CODE END 5 */
}

Here is the caller graph for this function:

SystemClock_Config()

void SystemClock_Config

(

void

)

System Clock Configuration.

Return values

None

Configure LSE Drive Capability

Configure the main internal regulator output voltage

Initializes the RCC Oscillators according to the specified parameters in the RCC_OscInitTypeDef structure.

Initializes the CPU, AHB and APB buses clocks

Definition at line 390 of file main.c.

{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  HAL_PWR_EnableBkUpAccess();
 
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE3);
 
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 4;
  RCC_OscInitStruct.PLL.PLLN = 96;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV4;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  RCC_OscInitStruct.PLL.PLLR = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
 
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

vApplicationIdleHook()

void vApplicationIdleHook

(

void

)

Definition at line 1492 of file main.c.

                                {
    // Called when no tasks are running
    // Can enter low power mode here
}

vApplicationMallocFailedHook()

void vApplicationMallocFailedHook

(

void

)

Definition at line 1487 of file main.c.

                                        {
    //printf("ERROR: FreeRTOS malloc failed!\n");
    for(;;);
}

vApplicationStackOverflowHook()

void vApplicationStackOverflowHook	(	TaskHandle_t	xTask,
		char *	pcTaskName
	)

Definition at line 1497 of file main.c.

                                                                         {
    //printf("ERROR: Stack overflow in task: %s\n", pcTaskName);
    for(;;);
}

vApplicationTickHook()

void vApplicationTickHook

(

void

)

Definition at line 1502 of file main.c.

                                {
    // Called on each FreeRTOS tick (optional)
    // Keep this very short and fast
}

Variable Documentation

adc1_buffer

uint32_t adc1_buffer[ADC1_CHANNEL_SIZE]

Definition at line 125 of file main.c.

adc2_buffer

uint32_t adc2_buffer[ADC2_CHANNEL_SIZE]

Definition at line 126 of file main.c.

adc3_buffer

uint32_t adc3_buffer[ADC3_CHANNEL_SIZE]

Definition at line 127 of file main.c.

dac1_buffer

uint32_t dac1_buffer[DAC1_BUFFER_SIZE]

Definition at line 128 of file main.c.

dac2_buffer

uint32_t dac2_buffer[DAC2_BUFFER_SIZE]

Definition at line 129 of file main.c.

defaultTask_attributes

const osThreadAttr_t defaultTask_attributes

Initial value:

= {
  .name = "defaultTask",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityNormal,
}

Definition at line 91 of file main.c.

defaultTaskHandle

osThreadId_t defaultTaskHandle

Definition at line 90 of file main.c.

digital_in_buffer

uint8_t digital_in_buffer[NUM_DIGITAL_INPUTS]

Definition at line 131 of file main.c.

digital_out_buffer

uint8_t digital_out_buffer[NUM_DIGITAL_OUTPUTS]

Definition at line 130 of file main.c.

hadc1

ADC_HandleTypeDef hadc1

Definition at line 63 of file main.c.

hadc2

ADC_HandleTypeDef hadc2

Definition at line 64 of file main.c.

hadc3

ADC_HandleTypeDef hadc3

Definition at line 65 of file main.c.

hcan1

CAN_HandleTypeDef hcan1

Definition at line 70 of file main.c.

hcan2

CAN_HandleTypeDef hcan2

Definition at line 71 of file main.c.

hcan3

CAN_HandleTypeDef hcan3

Definition at line 72 of file main.c.

hdac

DAC_HandleTypeDef hdac

Definition at line 74 of file main.c.

hdma_adc1

DMA_HandleTypeDef hdma_adc1

Definition at line 66 of file main.c.

hdma_adc2

DMA_HandleTypeDef hdma_adc2

Definition at line 67 of file main.c.

hdma_adc3

DMA_HandleTypeDef hdma_adc3

Definition at line 68 of file main.c.

hdma_dac1

DMA_HandleTypeDef hdma_dac1

Definition at line 75 of file main.c.

hdma_dac2

DMA_HandleTypeDef hdma_dac2

Definition at line 76 of file main.c.

hi2c2

I2C_HandleTypeDef hi2c2

Definition at line 78 of file main.c.

hi2c4

I2C_HandleTypeDef hi2c4

Definition at line 79 of file main.c.

hspi4

SPI_HandleTypeDef hspi4

Definition at line 81 of file main.c.

hspi6

SPI_HandleTypeDef hspi6

Definition at line 82 of file main.c.

htim1

TIM_HandleTypeDef htim1

Definition at line 84 of file main.c.

htim2

TIM_HandleTypeDef htim2

Definition at line 85 of file main.c.

huart3

UART_HandleTypeDef huart3

Definition at line 87 of file main.c.