main.c File Reference

: Main program body for the flight computer. Initializes hardware, RTOS, and starts all application tasks. More...

#include "main.h"
#include "cmsis_os.h"
#include "kalmanFilter.h"
#include "mekf.h"
#include "OptimalAngle.h"
#include "z_qflash_W25QXXX.h"
#include "attitude_estimation.h"
#include "buzzer.h"
#include "profiler.h"

Include dependency graph for main.c:

Go to the source code of this file.

Data Structures
struct	Linear_IMU_Package
	Represents a 3-axis linear acceleration data packet. More...
struct	Data_Package_no_Linear_IMU
	A comprehensive sensor data packet, excluding linear acceleration. More...
struct	Data_Package_For_Marconi
	Data packet formatted for transmission to the Marconi ground station. More...

Macros
#define	SENSOR_FLAG   (1U << 0)
#define	MPC_FLAG   (1U << 1)
#define	RECEIVED_VEL_FLAG   (1U << 2)
#define	KALMAN_FLAG   (1U << 3)
#define	FSM_FLAG   (1U << 4)
#define	UART_RX_ERROR_FLAG   (1U << 5)

Functions
static double P[]	__attribute__ ((aligned(4)))
void	SystemClock_Config (void)
	System Clock Configuration.
void	PeriphCommonClock_Config (void)
	Peripherals Common Clock Configuration.
static void	MPU_Config (void)
static void	MX_GPIO_Init (void)
	GPIO Initialization Function.
static void	MX_DMA_Init (void)
static void	MX_MDMA_Init (void)
static void	MX_USART1_UART_Init (void)
	USART1 Initialization Function.
static void	MX_USB_OTG_FS_PCD_Init (void)
	USB_OTG_FS Initialization Function.
static void	MX_FDCAN1_Init (void)
	FDCAN1 Initialization Function.
static void	MX_QUADSPI_Init (void)
	QUADSPI Initialization Function.
static void	MX_SPI1_Init (void)
	SPI1 Initialization Function.
static void	MX_SPI2_Init (void)
	SPI2 Initialization Function.
static void	MX_SPI3_Init (void)
	SPI3 Initialization Function.
static void	MX_TIM2_Init (void)
	TIM2 Initialization Function.
static void	MX_TIM15_Init (void)
	TIM15 Initialization Function.
static void	MX_UART4_Init (void)
	UART4 Initialization Function.
static void	MX_ADC1_Init (void)
	ADC1 Initialization Function.
static void	MX_ADC2_Init (void)
	ADC2 Initialization Function.
static void	MX_ADC3_Init (void)
	ADC3 Initialization Function.
static void	MX_TIM7_Init (void)
	TIM7 Initialization Function.
static void	MX_TIM6_Init (void)
	TIM6 Initialization Function.
static void	MX_TIM13_Init (void)
	TIM13 Initialization Function.
void	StartSensor_Task (void *argument)
	Function implementing the Sensor_Task thread.
void	StartFSM (void *argument)
	Function implementing the FSM thread.
void	StartKalman_mkf (void *argument)
	Function implementing the Kalman_mkf thread.
void	StartMPC_Task (void *argument)
	Function implementing the MPC_Task thread.
void	StartReceiveVel_Task (void *argument)
	Function implementing the ReceiveVel_Task thread.
void	HAL_UART_RxCpltCallback (UART_HandleTypeDef *huart)
void	HAL_UART_ErrorCallback (UART_HandleTypeDef *huart)
int	main (void)
	The application entry point.
void	HAL_TIM_PeriodElapsedCallback (TIM_HandleTypeDef *htim)
	Period elapsed callback in non blocking mode.
void	Error_Handler (void)
	This function is executed in case of error occurrence.

Variables
ADC_HandleTypeDef	hadc1
ADC_HandleTypeDef	hadc2
ADC_HandleTypeDef	hadc3
FDCAN_HandleTypeDef	hfdcan1
QSPI_HandleTypeDef	hqspi
	HAL QSPI handle for the external flash memory.
MDMA_HandleTypeDef	hmdma_quadspi_fifo_th
SPI_HandleTypeDef	hspi1
SPI_HandleTypeDef	hspi2
	HAL SPI handle for Sensor Bus 1 (e.g., IMU, Baro).
SPI_HandleTypeDef	hspi3
	HAL SPI handle for Sensor Bus 2 (e.g., secondary sensors).
TIM_HandleTypeDef	htim2
TIM_HandleTypeDef	htim6
TIM_HandleTypeDef	htim7
TIM_HandleTypeDef	htim13
TIM_HandleTypeDef	htim15
	HAL Timer handle for the buzzer PWM.
UART_HandleTypeDef	huart4
UART_HandleTypeDef	huart1
DMA_HandleTypeDef	hdma_usart1_rx
DMA_HandleTypeDef	hdma_usart1_tx
PCD_HandleTypeDef	hpcd_USB_OTG_FS
osThreadId_t	Sensor_TaskHandle
const osThreadAttr_t	Sensor_Task_attributes
osThreadId_t	FSMHandle
const osThreadAttr_t	FSM_attributes
osThreadId_t	Kalman_mkfHandle
const osThreadAttr_t	Kalman_mkf_attributes
osThreadId_t	MPC_TaskHandle
const osThreadAttr_t	MPC_Task_attributes
osThreadId_t	ReceiveVel_TaskHandle
const osThreadAttr_t	ReceiveVel_Task_attributes
flight_phase_t	flight_phase = CALIBRATING
flight_fsm_t	flight_state
buzzer_t *	bz ={0}
struct bmp3_dev	bmp390_1 = {0}
struct bmp3_dev	bmp390_2 = {0}
stmdev_ctx_t	imu_1 = {0}
stmdev_ctx_t	imu_2 = {0}
struct bmp3_data	barometer_data_1 = {-1, -1}
struct bmp3_data	barometer_data_2 = {-1, -1}
static int16_t	data_raw_angular_rate_1 [3] = {0}
static int16_t	data_raw_acceleration_1 [3] = {0}
static float_t	acceleration_mg_1 [3] = {0}
static float_t	angular_rate_mdps_1 [3] = {0}
stmdev_ctx_t	lis2mdl_dev_ctx
stmdev_ctx_t	lis2mdl_dev_ctx_2
int16_t	raw_mag_data [3]
float_t	altitude = 0.0
float_t	velocity = 0.0
float_t	Pressure_1 = 0.0
float_t	Temperature_1 = 0.0
Data_Package_For_Marconi	message = {0}
uint8_t	drogue = 0
	Status flag for the drogue parachute pyro channel.
uint8_t	mainp = 0
	Status flag for the main parachute pyro channel.
float	max_alt = 0
float	max_vel =0
bool	first_measure = true
double	q [] = {0.7061377159181262, -0.03700710955926802, 0.03700710955926802, -0.7061377159181262}
double	beta [] = {0, 0, 0}
double	omega [] = {3.760494829166693e-05, -1.4118446451604494e-07, 0.0003572545679652845}
double	b_B [] = {0,0,0}
double	q_new [] = {0,0,0,0}
double	beta_new [] = {0,0,0}
double	P_2 [] = {5,0,0,5}
double	z [] = {5003.24140978,329.14706741}
double	alpha = 0.0
double	a_m = -12.09
double	Ts = 0.01
const double	Q [] = {2769,1846,1846,1385}
const double	R [] = {5.54e-3,0,0,0.121}
double	x_est [] = {5000,330}
double	time_step = 0.5
double	sim_time_step = 0.5
double	current_delta = 0
double	target_apogee = 8900
double	tolerance = 1
double	tilt_angle = 0.24556997475102937
const double	mach_states [] = {0.1,0.2,0.3,0.4,0.5}
const double	deployment_states [] ={0.0,40.5000,69.7500,94.5000,108.0000,173.8000}
static double	cd_table [] ={0.4510,0.3940,0.3610,0.3390,0.3320,0.5430,0.4960,0.4690,0.4250,0.4170,0.6240,0.5790,0.5550,0.5350,0.5280, 0.7450,0.7140,0.6780,0.6760,0.6720,0.7520,0.7230,0.6980,0.6850,0.6820,0.85,0.81,0.8,0.8,0.8}
double	z_component = 0.0
TaskHandle_t	xReceived_VelHandle = NULL
TaskHandle_t	xMPCTaskHandle = NULL
TaskHandle_t	xSensorsTaskHandle = NULL
TaskHandle_t	xKalman_TaskHandle = NULL
osThreadId_t	xReceived_VelID =NULL
osThreadId_t	xMPCTaskID = NULL
osThreadId_t	xSensorsTaskID = NULL
osThreadId_t	xKalman_TaskID = NULL
uint8_t	vel [4]
float	gps_vel = 0.0f
uint8_t	array [63]
bool	gnss_flag = false
bool	flag_kf = false
	RTOS event flag to trigger the Kalman Filter task.
bool	flag_attitude = false
	RTOS event flag to trigger the attitude estimation task.
bool	flag_MPC = false
	RTOS event flag to trigger the MPC task.
bool	flag_flash = false
	RTOS event flag to trigger the data logging task.
uint32_t	flash_address = 4
uint8_t	data_buffer [4224] ={0}
uint8_t	cpy_buffer [2112] = {0}
uint32_t	num_of_lin_acc_saved = 0
uint32_t	num_of_saved_rest_packages = 0
uint32_t	num_of_saved_rest_packages_locked = 0
uint32_t	num_of_lin_acc_saved_flash = 0
uint32_t	num_of_saved_rest_packages_flash = 0
float	initial_flag_value = 0.0f
float	Vin =0
float	Vr =0
uint32_t	adcVal = 0
note_t	Partition []

Detailed Description

: Main program body for the flight computer. Initializes hardware, RTOS, and starts all application tasks.

Author

: Francesco Abate, Giorgio Montesi, Tommaso Gualtierotti

Attention

Copyright (c) 2025 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.

Macro Definition Documentation

FSM_FLAG

#define FSM_FLAG   (1U << 4)

Definition at line 287 of file main.c.

KALMAN_FLAG

#define KALMAN_FLAG   (1U << 3)

Definition at line 286 of file main.c.

MPC_FLAG

#define MPC_FLAG   (1U << 1)

Definition at line 284 of file main.c.

RECEIVED_VEL_FLAG

#define RECEIVED_VEL_FLAG   (1U << 2)

Definition at line 285 of file main.c.

SENSOR_FLAG

#define SENSOR_FLAG   (1U << 0)

Definition at line 283 of file main.c.

UART_RX_ERROR_FLAG

#define UART_RX_ERROR_FLAG   (1U << 5)

Definition at line 288 of file main.c.

Function Documentation

__attribute__()

static double P[] __attribute__ ( (aligned(4))  )

static

Error_Handler()

void Error_Handler

(

void

)

This function is executed in case of error occurrence.

Return values

None

Definition at line 2042 of file main.c.

{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

Referenced by buzzer_init(), HAL_FDCAN_MspInit(), HAL_PCD_MspInit(), HAL_QSPI_MspInit(), HAL_SPI_MspInit(), HAL_UART_MspInit(), main(), MX_ADC1_Init(), MX_ADC2_Init(), MX_ADC3_Init(), MX_FDCAN1_Init(), MX_QUADSPI_Init(), MX_SPI1_Init(), MX_SPI2_Init(), MX_SPI3_Init(), MX_TIM13_Init(), MX_TIM15_Init(), MX_TIM2_Init(), MX_TIM6_Init(), MX_TIM7_Init(), MX_UART4_Init(), MX_USART1_UART_Init(), MX_USB_OTG_FS_PCD_Init(), PeriphCommonClock_Config(), StartReceiveVel_Task(), and SystemClock_Config().

Here is the caller graph for this function:

HAL_TIM_PeriodElapsedCallback()

void HAL_TIM_PeriodElapsedCallback

(

TIM_HandleTypeDef *

htim

)

Period elapsed callback in non blocking mode.

Note

This function is called when TIM4 interrupt took place, inside HAL_TIM_IRQHandler(). It makes a direct call to HAL_IncTick() to increment a global variable "uwTick" used as application time base.

Parameters

htim	: TIM handle

Return values

None

Definition at line 2006 of file main.c.

{
  /* USER CODE BEGIN Callback 0 */
 
  /* USER CODE END Callback 0 */
  if (htim->Instance == TIM4)
  {
    HAL_IncTick();
  }
  /* USER CODE BEGIN Callback 1 */
  if (htim->Instance == TIM7) { //500 ms
      if (HAL_UART_GetState(&huart1) == HAL_UART_STATE_READY || HAL_UART_GetState(&huart1) == HAL_UART_STATE_BUSY_RX) // Ready or only busy receiving
      {
 
          osThreadFlagsSet(MPC_TaskHandle, MPC_FLAG);
      }
    }
 
  if (htim->Instance == TIM6) { // <<< Check for the 4kHz (0.25ms) timer
 
          osThreadFlagsSet(Sensor_TaskHandle, SENSOR_FLAG);
 
 
  }
 
  if(htim->Instance == TIM13){ // 10ms timer for the FSM
      osThreadFlagsSet(FSMHandle, FSM_FLAG);
  }
 
  /* USER CODE END Callback 1 */
}

References FSM_FLAG, FSMHandle, huart1, MPC_FLAG, MPC_TaskHandle, SENSOR_FLAG, and Sensor_TaskHandle.

HAL_UART_ErrorCallback()

void HAL_UART_ErrorCallback

(

UART_HandleTypeDef *

huart

)

Definition at line 379 of file main.c.

                                                      {
    if (huart->Instance == USART1){
        uint32_t error = HAL_UART_GetError(huart);
        __HAL_UART_CLEAR_OREFLAG(huart);
        HAL_UART_AbortReceive(huart); // This should handle associated DMA abort too
 
 
        if (ReceiveVel_TaskHandle != NULL) { // Ensure task handle is valid
            osThreadFlagsSet(ReceiveVel_TaskHandle, UART_RX_ERROR_FLAG);
        }
    }
}

References NULL, ReceiveVel_TaskHandle, and UART_RX_ERROR_FLAG.

HAL_UART_RxCpltCallback()

void HAL_UART_RxCpltCallback

(

UART_HandleTypeDef *

huart

)

Definition at line 370 of file main.c.

                                                        {
    if (huart->Instance == USART1) {
 
        osThreadFlagsSet(ReceiveVel_TaskHandle, RECEIVED_VEL_FLAG);
 
 
    }
}

References RECEIVED_VEL_FLAG, and ReceiveVel_TaskHandle.

main()

int main

(

void

)

The application entry point.

Return values

int

Definition at line 399 of file main.c.

{
 
  /* USER CODE BEGIN 1 */
 
  /* USER CODE END 1 */
 
  /* MPU Configuration--------------------------------------------------------*/
  MPU_Config();
 
  /* 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();
 
  /* Configure the peripherals common clocks */
  PeriphCommonClock_Config();
 
  /* USER CODE BEGIN SysInit */
  initDWT();
  /* USER CODE END SysInit */
 
  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_MDMA_Init();
  MX_USART1_UART_Init();
  MX_USB_OTG_FS_PCD_Init();
  MX_FDCAN1_Init();
  MX_QUADSPI_Init();
  MX_SPI1_Init();
  MX_SPI2_Init();
  MX_SPI3_Init();
  MX_TIM2_Init();
  MX_TIM15_Init();
  MX_UART4_Init();
  MX_ADC1_Init();
  MX_ADC2_Init();
  MX_ADC3_Init();
  MX_TIM7_Init();
  MX_TIM6_Init();
  MX_TIM13_Init();
  /* USER CODE BEGIN 2 */
  //----------------------------------------------------------------------------------------------------------------------------------------
//TODO CODICE PER INIZIALIZZARE I  MAGNETOMETRI, COMMENTATO FINQUANDO AVREMO UNA SCHEDA CON I MAGNETOMETRI GIRATI NEL VERSO GIUSTO
  //uint8_t result = lis2mdl_init(&lis2mdl_dev_ctx);
  //uint8_t result_7 = lis2mdl_init_2(&lis2mdl_dev_ctx_2);
//TODO: SETTAGGIO DELL'SPI IN 4WAY PIUTTOSTO CHE 3WAY, SERVE A GESTIRE LA QUESTIONE DEL REGISTRO DEL MAGNETOMETRO, SE GIA STA SU 4WAY NO NEED
  //  HAL_SPI_DeInit(&hspi2);
  //  HAL_Delay(10);
  //  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  //  HAL_SPI_Init(&hspi2);
  //----------------------------------------------------------------------------------------------------------------------------------------
 
  LED_ON(GPIO_LED_FLASH_GPIO_Port, GPIO_LED_FLASH_Pin);
 
 
 
  IMU_CS_HIGH;
  MAG_CS_HIGH;
  BMP390_CS_HIGH;
 
  HAL_Delay(100);
 
 
  uint8_t result_4 = init_bmp390_B(&bmp390_2);
 
  uint8_t result_2 = init_imuB(&imu_2, LSM6DSO32_16g, LSM6DSO32_2000dps, LSM6DSO32_XL_ODR_6667Hz_HIGH_PERF, LSM6DSO32_GY_ODR_208Hz_HIGH_PERF);
 
  //TODO: the result of the init of the backup of the imu and of the barometer are currently not checked, we can add a very similar snippet of code to the lines 494 to 498 but using a different LED
 
  uint8_t result_3 = init_bmp390_p(&bmp390_1);
 
  uint8_t result_1 = init_imup(&imu_1, LSM6DSO32_16g, LSM6DSO32_2000dps, LSM6DSO32_XL_ODR_6667Hz_HIGH_PERF, LSM6DSO32_GY_ODR_208Hz_HIGH_PERF);
 
 
  if(result_1 != 0 || result_3 != 0){
    LED_ON(GPIO_LED2_GPIO_Port, GPIO_LED2_Pin);
  }
 
  calibrateIMU(&imu_1, 1000, HWOFFSET);
  calibrateIMU(&imu_2, 1000, HWOFFSET);
 
 
  buzzer_init(bz, &htim15, TIM_CHANNEL_2);
 
  musica_maestro(bz,Partition,sizeof(Partition)/sizeof(note_t));
 
 
  if (QFlash_Init() != 0) {
          // Handle initialization error
          Error_Handler();
  }
 
 
  uint8_t small_buffer[4];
  if (QFlash_Read(0, (uint8_t*)small_buffer, 4) != HAL_OK) {
      // Handle read error
      Error_Handler();
  }
 
  memcpy(&initial_flag_value, (uint8_t*)small_buffer, 4);
 
  if(initial_flag_value != 1.0) {
      HAL_TIM_PWM_Start(&htim15, TIM_CHANNEL_2);
 
      for(int i = 0; i < 10; i++) {
          __HAL_TIM_SET_PRESCALER(&htim15, NOTE_B5);
          HAL_Delay(100);
          __HAL_TIM_SET_PRESCALER(&htim15, 0);
          HAL_Delay(100);
          __HAL_TIM_SET_PRESCALER(&htim15, NOTE_B5);
          HAL_Delay(100);
          __HAL_TIM_SET_PRESCALER(&htim15, 0);
 
          HAL_Delay(700);
      }
 
      __HAL_TIM_SET_PRESCALER(&htim15, NOTE_B5);
      HAL_Delay(1000);
 
      HAL_TIM_PWM_Stop(&htim15, TIM_CHANNEL_2);
 
      QFlash_ChipErase();
 
      HAL_TIM_PWM_Start(&htim15, TIM_CHANNEL_2);
 
      __HAL_TIM_SET_PRESCALER(&htim15, NOTE_B5);
      HAL_Delay(700);
 
      HAL_TIM_PWM_Stop(&htim15, TIM_CHANNEL_2);
  }
 
  LED_ON(GPIO_LED1_GPIO_Port, GPIO_LED1_Pin);
  flight_state.flight_state = flight_phase;
 
 
 
  /* 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 Sensor_Task */
  Sensor_TaskHandle = osThreadNew(StartSensor_Task, NULL, &Sensor_Task_attributes);
 
  /* creation of FSM */
  FSMHandle = osThreadNew(StartFSM, NULL, &FSM_attributes);
 
  /* creation of Kalman_mkf */
  Kalman_mkfHandle = osThreadNew(StartKalman_mkf, NULL, &Kalman_mkf_attributes);
 
  /* creation of MPC_Task */
  MPC_TaskHandle = osThreadNew(StartMPC_Task, NULL, &MPC_Task_attributes);
 
  /* creation of ReceiveVel_Task */
  ReceiveVel_TaskHandle = osThreadNew(StartReceiveVel_Task, NULL, &ReceiveVel_Task_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 */
 
  while (1)
  {
    /* USER CODE END WHILE */
 
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

References bmp390_1, bmp390_2, buzzer_init(), bz, calibrateIMU(), Error_Handler(), flight_phase, flight_fsm_t::flight_state, flight_state, FSM_attributes, FSMHandle, HAL_OK, htim15, HWOFFSET, imu_1, imu_2, init_bmp390_B(), init_bmp390_p(), init_imuB(), init_imup(), initDWT(), initial_flag_value, Kalman_mkf_attributes, Kalman_mkfHandle, LSM6DSO32_16g, LSM6DSO32_2000dps, LSM6DSO32_GY_ODR_208Hz_HIGH_PERF, LSM6DSO32_XL_ODR_6667Hz_HIGH_PERF, MPC_Task_attributes, MPC_TaskHandle, MPU_Config(), musica_maestro(), MX_ADC1_Init(), MX_ADC2_Init(), MX_ADC3_Init(), MX_DMA_Init(), MX_FDCAN1_Init(), MX_GPIO_Init(), MX_MDMA_Init(), MX_QUADSPI_Init(), MX_SPI1_Init(), MX_SPI2_Init(), MX_SPI3_Init(), MX_TIM13_Init(), MX_TIM15_Init(), MX_TIM2_Init(), MX_TIM6_Init(), MX_TIM7_Init(), MX_UART4_Init(), MX_USART1_UART_Init(), MX_USB_OTG_FS_PCD_Init(), NOTE_B5, NULL, Partition, PeriphCommonClock_Config(), QFlash_ChipErase(), QFlash_Init(), QFlash_Read(), ReceiveVel_Task_attributes, ReceiveVel_TaskHandle, Sensor_Task_attributes, Sensor_TaskHandle, StartFSM(), StartKalman_mkf(), StartMPC_Task(), StartReceiveVel_Task(), StartSensor_Task(), and SystemClock_Config().

Here is the call graph for this function:

MPU_Config()

void MPU_Config ( void  )

static

Initializes and configures the Region and the memory to be protected

Definition at line 1971 of file main.c.

{
  MPU_Region_InitTypeDef MPU_InitStruct = {0};
 
  /* Disables the MPU */
  HAL_MPU_Disable();
 
  MPU_InitStruct.Enable = MPU_REGION_ENABLE;
  MPU_InitStruct.Number = MPU_REGION_NUMBER0;
  MPU_InitStruct.BaseAddress = 0x0;
  MPU_InitStruct.Size = MPU_REGION_SIZE_4GB;
  MPU_InitStruct.SubRegionDisable = 0x87;
  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
  MPU_InitStruct.AccessPermission = MPU_REGION_NO_ACCESS;
  MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;
  MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;
  MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
  MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
 
  HAL_MPU_ConfigRegion(&MPU_InitStruct);
  /* Enables the MPU */
  HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
 
}

Referenced by main().

Here is the caller graph for this function:

MX_ADC1_Init()

static void MX_ADC1_Init ( void  )

static

ADC1 Initialization Function.

Parameters

None

Return values

None

Common config

Configure the ADC multi-mode

Configure Regular Channel

Definition at line 696 of file main.c.

{
 
  /* USER CODE BEGIN ADC1_Init 0 */
 
  /* USER CODE END ADC1_Init 0 */
 
  ADC_MultiModeTypeDef multimode = {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_ASYNC_DIV1;
  hadc1.Init.Resolution = ADC_RESOLUTION_16B;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
  hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc1.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
  hadc1.Init.OversamplingMode = DISABLE;
  hadc1.Init.Oversampling.Ratio = 1;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
 
  multimode.Mode = ADC_MODE_INDEPENDENT;
  if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_11;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  sConfig.OffsetSignedSaturation = DISABLE;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC1_Init 2 */
 
  /* USER CODE END ADC1_Init 2 */
 
}

References Error_Handler(), hadc1, and HAL_OK.

Referenced by main().

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

Common config

Configure Regular Channel

Definition at line 765 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_ASYNC_DIV1;
  hadc2.Init.Resolution = ADC_RESOLUTION_16B;
  hadc2.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc2.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc2.Init.LowPowerAutoWait = DISABLE;
  hadc2.Init.ContinuousConvMode = DISABLE;
  hadc2.Init.NbrOfConversion = 1;
  hadc2.Init.DiscontinuousConvMode = DISABLE;
  hadc2.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc2.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
  hadc2.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc2.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
  hadc2.Init.OversamplingMode = DISABLE;
  hadc2.Init.Oversampling.Ratio = 1;
  if (HAL_ADC_Init(&hadc2) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_9;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  sConfig.OffsetSignedSaturation = DISABLE;
  if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC2_Init 2 */
 
  /* USER CODE END ADC2_Init 2 */
 
}

References Error_Handler(), hadc2, and HAL_OK.

Referenced by main().

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

Common config

Configure Regular Channel

Definition at line 825 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_ASYNC_DIV1;
  hadc3.Init.Resolution = ADC_RESOLUTION_12B;
  hadc3.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc3.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
  hadc3.Init.LowPowerAutoWait = DISABLE;
  hadc3.Init.ContinuousConvMode = DISABLE;
  hadc3.Init.NbrOfConversion = 1;
  hadc3.Init.DiscontinuousConvMode = DISABLE;
  hadc3.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc3.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc3.Init.ConversionDataManagement = ADC_CONVERSIONDATA_DR;
  hadc3.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc3.Init.LeftBitShift = ADC_LEFTBITSHIFT_NONE;
  hadc3.Init.OversamplingMode = DISABLE;
  hadc3.Init.Oversampling.Ratio = 1;
  if (HAL_ADC_Init(&hadc3) != HAL_OK)
  {
    Error_Handler();
  }
 
  sConfig.Channel = ADC_CHANNEL_11;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  sConfig.OffsetSignedSaturation = DISABLE;
  if (HAL_ADC_ConfigChannel(&hadc3, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN ADC3_Init 2 */
 
  /* USER CODE END ADC3_Init 2 */
 
}

References Error_Handler(), hadc3, and HAL_OK.

Referenced by main().

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 1469 of file main.c.

{
 
  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();
 
  /* DMA interrupt init */
  /* DMA1_Stream0_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Stream0_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream0_IRQn);
  /* DMA1_Stream1_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Stream1_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(DMA1_Stream1_IRQn);
 
}

Referenced by main().

Here is the caller graph for this function:

MX_FDCAN1_Init()

static void MX_FDCAN1_Init ( void  )

static

FDCAN1 Initialization Function.

Parameters

None

Return values

None

Definition at line 885 of file main.c.

{
 
  /* USER CODE BEGIN FDCAN1_Init 0 */
 
  /* USER CODE END FDCAN1_Init 0 */
 
  /* USER CODE BEGIN FDCAN1_Init 1 */
 
  /* USER CODE END FDCAN1_Init 1 */
  hfdcan1.Instance = FDCAN1;
  hfdcan1.Init.FrameFormat = FDCAN_FRAME_CLASSIC;
  hfdcan1.Init.Mode = FDCAN_MODE_NORMAL;
  hfdcan1.Init.AutoRetransmission = DISABLE;
  hfdcan1.Init.TransmitPause = DISABLE;
  hfdcan1.Init.ProtocolException = DISABLE;
  hfdcan1.Init.NominalPrescaler = 16;
  hfdcan1.Init.NominalSyncJumpWidth = 1;
  hfdcan1.Init.NominalTimeSeg1 = 1;
  hfdcan1.Init.NominalTimeSeg2 = 1;
  hfdcan1.Init.DataPrescaler = 1;
  hfdcan1.Init.DataSyncJumpWidth = 1;
  hfdcan1.Init.DataTimeSeg1 = 1;
  hfdcan1.Init.DataTimeSeg2 = 1;
  hfdcan1.Init.MessageRAMOffset = 0;
  hfdcan1.Init.StdFiltersNbr = 0;
  hfdcan1.Init.ExtFiltersNbr = 0;
  hfdcan1.Init.RxFifo0ElmtsNbr = 0;
  hfdcan1.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.RxFifo1ElmtsNbr = 0;
  hfdcan1.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.RxBuffersNbr = 0;
  hfdcan1.Init.RxBufferSize = FDCAN_DATA_BYTES_8;
  hfdcan1.Init.TxEventsNbr = 0;
  hfdcan1.Init.TxBuffersNbr = 0;
  hfdcan1.Init.TxFifoQueueElmtsNbr = 0;
  hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION;
  hfdcan1.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
  if (HAL_FDCAN_Init(&hfdcan1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN FDCAN1_Init 2 */
 
  /* USER CODE END FDCAN1_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hfdcan1.

Referenced by main().

Here is the call graph for this function:

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 1507 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_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, GPIO_1_Pin|GPIO_LED_FLASH_Pin|GPIO_LED2_Pin|GPIO_LED3_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_2_Pin|GPIO_3_AIRBRAKES_AUX_Pin|GPIO4_CAMERA_Pin|GIO_SPI1_CS_Pin
                          |GPIO_LED_USB_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOD, BARO_CS_Pin|IMU_CS_Pin|MAG_CS_Pin|GPIO_LED1_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOC, GPIO_Pyro_EN1_Pin|GPIO_Pyro_EN2_Pin|GPIO_DaVinci_Marc_SYNC_Pin, GPIO_PIN_RESET);
 
  /*Configure GPIO pins : GPIO_1_Pin GPIO_LED_FLASH_Pin GPIO_LED2_Pin GPIO_LED3_Pin */
  GPIO_InitStruct.Pin = GPIO_1_Pin|GPIO_LED_FLASH_Pin|GPIO_LED2_Pin|GPIO_LED3_Pin;
  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 : GPIO_2_Pin GPIO_3_AIRBRAKES_AUX_Pin GPIO4_CAMERA_Pin GIO_SPI1_CS_Pin
                           GPIO_LED_USB_Pin */
  GPIO_InitStruct.Pin = GPIO_2_Pin|GPIO_3_AIRBRAKES_AUX_Pin|GPIO4_CAMERA_Pin|GIO_SPI1_CS_Pin
                          |GPIO_LED_USB_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
 
  /*Configure GPIO pins : BARO_CS_Pin IMU_CS_Pin MAG_CS_Pin GPIO_LED1_Pin */
  GPIO_InitStruct.Pin = BARO_CS_Pin|IMU_CS_Pin|MAG_CS_Pin|GPIO_LED1_Pin;
  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 pins : GPIO_Pyro_EN1_Pin GPIO_Pyro_EN2_Pin GPIO_DaVinci_Marc_SYNC_Pin */
  GPIO_InitStruct.Pin = GPIO_Pyro_EN1_Pin|GPIO_Pyro_EN2_Pin|GPIO_DaVinci_Marc_SYNC_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
 
  /*AnalogSwitch Config */
  HAL_SYSCFG_AnalogSwitchConfig(SYSCFG_SWITCH_PA0, SYSCFG_SWITCH_PA0_CLOSE);
 
  /*AnalogSwitch Config */
  HAL_SYSCFG_AnalogSwitchConfig(SYSCFG_SWITCH_PA1, SYSCFG_SWITCH_PA1_CLOSE);
 
  /* USER CODE BEGIN MX_GPIO_Init_2 */
 
  /* USER CODE END MX_GPIO_Init_2 */
}

Referenced by main().

Here is the caller graph for this function:

MX_MDMA_Init()

static void MX_MDMA_Init ( void  )

static

Enable MDMA controller clock

Definition at line 1488 of file main.c.

{
 
  /* MDMA controller clock enable */
  __HAL_RCC_MDMA_CLK_ENABLE();
  /* Local variables */
 
  /* MDMA interrupt initialization */
  /* MDMA_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(MDMA_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(MDMA_IRQn);
 
}

Referenced by main().

Here is the caller graph for this function:

MX_QUADSPI_Init()

static void MX_QUADSPI_Init ( void  )

static

QUADSPI Initialization Function.

Parameters

None

Return values

None

Definition at line 938 of file main.c.

{
 
  /* USER CODE BEGIN QUADSPI_Init 0 */
 
  /* USER CODE END QUADSPI_Init 0 */
 
  /* USER CODE BEGIN QUADSPI_Init 1 */
 
  /* USER CODE END QUADSPI_Init 1 */
  /* QUADSPI parameter configuration*/
  hqspi.Instance = QUADSPI;
  hqspi.Init.ClockPrescaler = 1;
  hqspi.Init.FifoThreshold = 32;
  hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_NONE;
  hqspi.Init.FlashSize = 25;
  hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_1_CYCLE;
  hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
  hqspi.Init.FlashID = QSPI_FLASH_ID_2;
  hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
  if (HAL_QSPI_Init(&hqspi) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN QUADSPI_Init 2 */
 
  /* USER CODE END QUADSPI_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hqspi.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_SPI1_Init()

static void MX_SPI1_Init ( void  )

static

SPI1 Initialization Function.

Parameters

None

Return values

None

Definition at line 973 of file main.c.

{
 
  /* USER CODE BEGIN SPI1_Init 0 */
 
  /* USER CODE END SPI1_Init 0 */
 
  /* USER CODE BEGIN SPI1_Init 1 */
 
  /* USER CODE END SPI1_Init 1 */
  /* SPI1 parameter configuration*/
  hspi1.Instance = SPI1;
  hspi1.Init.Mode = SPI_MODE_MASTER;
  hspi1.Init.Direction = SPI_DIRECTION_2LINES;
  hspi1.Init.DataSize = SPI_DATASIZE_4BIT;
  hspi1.Init.CLKPolarity = SPI_POLARITY_LOW;
  hspi1.Init.CLKPhase = SPI_PHASE_1EDGE;
  hspi1.Init.NSS = SPI_NSS_SOFT;
  hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
  hspi1.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi1.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi1.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi1.Init.CRCPolynomial = 0x0;
  hspi1.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  hspi1.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi1.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi1.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi1.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi1.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi1.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi1.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi1.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi1.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI1_Init 2 */
 
  /* USER CODE END SPI1_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hspi1.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_SPI2_Init()

static void MX_SPI2_Init ( void  )

static

SPI2 Initialization Function.

Parameters

None

Return values

None

Definition at line 1021 of file main.c.

{
 
  /* USER CODE BEGIN SPI2_Init 0 */
 
  /* USER CODE END SPI2_Init 0 */
 
  /* USER CODE BEGIN SPI2_Init 1 */
 
  /* USER CODE END SPI2_Init 1 */
  /* SPI2 parameter configuration*/
  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi2.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi2.Init.CRCPolynomial = 0x0;
  hspi2.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  hspi2.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi2.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi2.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi2.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi2.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi2.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi2.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi2.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi2.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi2) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI2_Init 2 */
 
  /* USER CODE END SPI2_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hspi2.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_SPI3_Init()

static void MX_SPI3_Init ( void  )

static

SPI3 Initialization Function.

Parameters

None

Return values

None

Definition at line 1069 of file main.c.

{
 
  /* USER CODE BEGIN SPI3_Init 0 */
 
  /* USER CODE END SPI3_Init 0 */
 
  /* USER CODE BEGIN SPI3_Init 1 */
 
  /* USER CODE END SPI3_Init 1 */
  /* SPI3 parameter configuration*/
  hspi3.Instance = SPI3;
  hspi3.Init.Mode = SPI_MODE_MASTER;
  hspi3.Init.Direction = SPI_DIRECTION_2LINES;
  hspi3.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi3.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi3.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi3.Init.NSS = SPI_NSS_SOFT;
  hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
  hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
  hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
  hspi3.Init.CRCPolynomial = 0x0;
  hspi3.Init.NSSPMode = SPI_NSS_PULSE_ENABLE;
  hspi3.Init.NSSPolarity = SPI_NSS_POLARITY_LOW;
  hspi3.Init.FifoThreshold = SPI_FIFO_THRESHOLD_01DATA;
  hspi3.Init.TxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi3.Init.RxCRCInitializationPattern = SPI_CRC_INITIALIZATION_ALL_ZERO_PATTERN;
  hspi3.Init.MasterSSIdleness = SPI_MASTER_SS_IDLENESS_00CYCLE;
  hspi3.Init.MasterInterDataIdleness = SPI_MASTER_INTERDATA_IDLENESS_00CYCLE;
  hspi3.Init.MasterReceiverAutoSusp = SPI_MASTER_RX_AUTOSUSP_DISABLE;
  hspi3.Init.MasterKeepIOState = SPI_MASTER_KEEP_IO_STATE_DISABLE;
  hspi3.Init.IOSwap = SPI_IO_SWAP_DISABLE;
  if (HAL_SPI_Init(&hspi3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SPI3_Init 2 */
 
  /* USER CODE END SPI3_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hspi3.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM13_Init()

static void MX_TIM13_Init ( void  )

static

TIM13 Initialization Function.

Parameters

None

Return values

None

Definition at line 1242 of file main.c.

{
 
  /* USER CODE BEGIN TIM13_Init 0 */
 
  /* USER CODE END TIM13_Init 0 */
 
  /* USER CODE BEGIN TIM13_Init 1 */
 
  /* USER CODE END TIM13_Init 1 */
  htim13.Instance = TIM13;
  htim13.Init.Prescaler = 239;
  htim13.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim13.Init.Period = 9999;
  htim13.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim13.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim13) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM13_Init 2 */
 
  /* USER CODE END TIM13_Init 2 */
 
}

References Error_Handler(), HAL_OK, and htim13.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM15_Init()

static void MX_TIM15_Init ( void  )

static

TIM15 Initialization Function.

Parameters

None

Return values

None

Definition at line 1273 of file main.c.

{
 
  /* USER CODE BEGIN TIM15_Init 0 */
 
  /* USER CODE END TIM15_Init 0 */
 
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
 
  /* USER CODE BEGIN TIM15_Init 1 */
 
  /* USER CODE END TIM15_Init 1 */
  htim15.Instance = TIM15;
  htim15.Init.Prescaler = 239;
  htim15.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim15.Init.Period = 999;
  htim15.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim15.Init.RepetitionCounter = 0;
  htim15.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_PWM_Init(&htim15) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim15, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 499;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim15, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.BreakFilter = 0;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim15, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM15_Init 2 */
 
  /* USER CODE END TIM15_Init 2 */
  HAL_TIM_MspPostInit(&htim15);
 
}

References Error_Handler(), HAL_OK, HAL_TIM_MspPostInit(), and htim15.

Referenced by main().

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 1117 of file main.c.

{
 
  /* USER CODE BEGIN TIM2_Init 0 */
 
  /* USER CODE END TIM2_Init 0 */
 
  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {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 = 4294967295;
  htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_PWM_Init(&htim2) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM2_Init 2 */
 
  /* USER CODE END TIM2_Init 2 */
  HAL_TIM_MspPostInit(&htim2);
 
}

References Error_Handler(), HAL_OK, HAL_TIM_MspPostInit(), and htim2.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM6_Init()

static void MX_TIM6_Init ( void  )

static

TIM6 Initialization Function.

Parameters

None

Return values

None

Definition at line 1166 of file main.c.

{
 
  /* USER CODE BEGIN TIM6_Init 0 */
 
  /* USER CODE END TIM6_Init 0 */
 
  TIM_MasterConfigTypeDef sMasterConfig = {0};
 
  /* USER CODE BEGIN TIM6_Init 1 */
 
  /* USER CODE END TIM6_Init 1 */
  htim6.Instance = TIM6;
  htim6.Init.Prescaler = 5999;
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.Period = 9;
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM6_Init 2 */
 
  /* USER CODE END TIM6_Init 2 */
 
}

References Error_Handler(), HAL_OK, and htim6.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM7_Init()

static void MX_TIM7_Init ( void  )

static

TIM7 Initialization Function.

Parameters

None

Return values

None

Definition at line 1204 of file main.c.

{
 
  /* USER CODE BEGIN TIM7_Init 0 */
 
  /* USER CODE END TIM7_Init 0 */
 
  TIM_MasterConfigTypeDef sMasterConfig = {0};
 
  /* USER CODE BEGIN TIM7_Init 1 */
 
  /* USER CODE END TIM7_Init 1 */
  htim7.Instance = TIM7;
  htim7.Init.Prescaler = 23999;
  htim7.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim7.Init.Period = 4999;
  htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim7) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM7_Init 2 */
 
  /* USER CODE END TIM7_Init 2 */
 
}

References Error_Handler(), HAL_OK, and htim7.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_UART4_Init()

static void MX_UART4_Init ( void  )

static

UART4 Initialization Function.

Parameters

None

Return values

None

Definition at line 1339 of file main.c.

{
 
  /* USER CODE BEGIN UART4_Init 0 */
 
  /* USER CODE END UART4_Init 0 */
 
  /* USER CODE BEGIN UART4_Init 1 */
 
  /* USER CODE END UART4_Init 1 */
  huart4.Instance = UART4;
  huart4.Init.BaudRate = 115200;
  huart4.Init.WordLength = UART_WORDLENGTH_8B;
  huart4.Init.StopBits = UART_STOPBITS_1;
  huart4.Init.Parity = UART_PARITY_NONE;
  huart4.Init.Mode = UART_MODE_TX_RX;
  huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart4.Init.OverSampling = UART_OVERSAMPLING_16;
  huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart4) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart4, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart4, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart4) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN UART4_Init 2 */
 
  /* USER CODE END UART4_Init 2 */
 
}

References Error_Handler(), HAL_OK, and huart4.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_USART1_UART_Init()

static void MX_USART1_UART_Init ( void  )

static

USART1 Initialization Function.

Parameters

None

Return values

None

Definition at line 1387 of file main.c.

{
 
  /* USER CODE BEGIN USART1_Init 0 */
 
  /* USER CODE END USART1_Init 0 */
 
  /* USER CODE BEGIN USART1_Init 1 */
 
  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 1843200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_EnableFifoMode(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
 
  /* USER CODE END USART1_Init 2 */
 
}

References Error_Handler(), HAL_OK, and huart1.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

MX_USB_OTG_FS_PCD_Init()

static void MX_USB_OTG_FS_PCD_Init ( void  )

static

USB_OTG_FS Initialization Function.

Parameters

None

Return values

None

Definition at line 1435 of file main.c.

{
 
  /* USER CODE BEGIN USB_OTG_FS_Init 0 */
 
  /* USER CODE END USB_OTG_FS_Init 0 */
 
  /* USER CODE BEGIN USB_OTG_FS_Init 1 */
 
  /* USER CODE END USB_OTG_FS_Init 1 */
  hpcd_USB_OTG_FS.Instance = USB_OTG_FS;
  hpcd_USB_OTG_FS.Init.dev_endpoints = 9;
  hpcd_USB_OTG_FS.Init.speed = PCD_SPEED_FULL;
  hpcd_USB_OTG_FS.Init.dma_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.phy_itface = PCD_PHY_EMBEDDED;
  hpcd_USB_OTG_FS.Init.Sof_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.low_power_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.lpm_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.battery_charging_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.vbus_sensing_enable = DISABLE;
  hpcd_USB_OTG_FS.Init.use_dedicated_ep1 = DISABLE;
  if (HAL_PCD_Init(&hpcd_USB_OTG_FS) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USB_OTG_FS_Init 2 */
 
  /* USER CODE END USB_OTG_FS_Init 2 */
 
}

References Error_Handler(), HAL_OK, and hpcd_USB_OTG_FS.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

PeriphCommonClock_Config()

void PeriphCommonClock_Config

(

void

)

Peripherals Common Clock Configuration.

Return values

None

Initializes the peripherals clock

Definition at line 669 of file main.c.

{
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
 
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_ADC;
  PeriphClkInitStruct.PLL2.PLL2M = 1;
  PeriphClkInitStruct.PLL2.PLL2N = 10;
  PeriphClkInitStruct.PLL2.PLL2P = 2;
  PeriphClkInitStruct.PLL2.PLL2Q = 2;
  PeriphClkInitStruct.PLL2.PLL2R = 2;
  PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_3;
  PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOMEDIUM;
  PeriphClkInitStruct.PLL2.PLL2FRACN = 0;
  PeriphClkInitStruct.AdcClockSelection = RCC_ADCCLKSOURCE_PLL2;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
}

References Error_Handler(), and HAL_OK.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

StartReceiveVel_Task()

void StartReceiveVel_Task

(

void *

argument

)

Function implementing the ReceiveVel_Task thread.

Parameters

argument

Not used

Return values

None

Definition at line 1943 of file main.c.

{
  /* USER CODE BEGIN StartReceiveVel_Task */
  /* Infinite loop */
  if (HAL_UART_Receive_DMA(&huart1, vel, 4) != HAL_OK) {
      Error_Handler();
  }
 
  for(;;)
  {
      uint32_t flags = osThreadFlagsWait(RECEIVED_VEL_FLAG , osFlagsWaitAny, osWaitForever);
 
      if (flags & RECEIVED_VEL_FLAG) {
          memcpy(&gps_vel,(uint8_t*)vel,sizeof(vel));
          HAL_UART_Receive_DMA(&huart1, vel, 4);
 
          gnss_flag = gps_vel > 0;
 
          if(gnss_flag) {
              LED_TOGGLE(GPIO_LED_USB_GPIO_Port, GPIO_LED_USB_Pin);
          }
      }
  }
  /* USER CODE END StartReceiveVel_Task */
}

References Error_Handler(), gnss_flag, gps_vel, HAL_OK, huart1, RECEIVED_VEL_FLAG, and vel.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

SystemClock_Config()

void SystemClock_Config

(

void

)

System Clock Configuration.

Return values

None

Supply configuration update enable

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 611 of file main.c.

{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
  HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);
 
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE0);
 
  while(!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY)) {}
 
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 60;
  RCC_OscInitStruct.PLL.PLLP = 2;
  RCC_OscInitStruct.PLL.PLLQ = 15;
  RCC_OscInitStruct.PLL.PLLR = 2;
  RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
  RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
  RCC_OscInitStruct.PLL.PLLFRACN = 0;
  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_CLOCKTYPE_D3PCLK1|RCC_CLOCKTYPE_D1PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
  RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;
 
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
  {
    Error_Handler();
  }
}

References Error_Handler(), and HAL_OK.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

a_m

double a_m = -12.09

Definition at line 250 of file main.c.

Referenced by kalmanFilter(), StartKalman_mkf(), and StartSensor_Task().

acceleration_mg_1

float_t acceleration_mg_1[3] = {0}

static

Definition at line 132 of file main.c.

Referenced by StartFSM(), StartMPC_Task(), and StartSensor_Task().

adcVal

uint32_t adcVal = 0

Definition at line 323 of file main.c.

Referenced by StartMPC_Task().

alpha

double alpha = 0.0

Definition at line 249 of file main.c.

Referenced by attitude_estimation(), kalmanFilter(), StartKalman_mkf(), and StartMPC_Task().

altitude

float_t altitude = 0.0

Definition at line 224 of file main.c.

Referenced by optimalAngle(), readAltitude(), StartFSM(), StartKalman_mkf(), StartMPC_Task(), and StartSensor_Task().

angular_rate_mdps_1

float_t angular_rate_mdps_1[3] = {0}

static

Definition at line 133 of file main.c.

Referenced by StartMPC_Task(), and StartSensor_Task().

array

uint8_t array[63]

Definition at line 296 of file main.c.

Referenced by StartMPC_Task().

b_B

double b_B[] = {0,0,0}

Definition at line 241 of file main.c.

Referenced by mekf().

barometer_data_1

struct bmp3_data barometer_data_1 = {-1, -1}

Definition at line 126 of file main.c.

Referenced by StartMPC_Task(), and StartSensor_Task().

barometer_data_2

struct bmp3_data barometer_data_2 = {-1, -1}

Definition at line 127 of file main.c.

beta

double beta[] = {0, 0, 0}

Definition at line 238 of file main.c.

Referenced by mekf().

beta_new

double beta_new[] = {0,0,0}

Definition at line 244 of file main.c.

Referenced by mekf().

bmp390_1

struct bmp3_dev bmp390_1 = {0}

Definition at line 122 of file main.c.

Referenced by main(), and StartSensor_Task().

bmp390_2

struct bmp3_dev bmp390_2 = {0}

Definition at line 122 of file main.c.

Referenced by main().

bz

buzzer_t* bz ={0}

Definition at line 121 of file main.c.

Referenced by buzzer_init(), main(), and musica_maestro().

cd_table

double cd_table[] ={0.4510,0.3940,0.3610,0.3390,0.3320,0.5430,0.4960,0.4690,0.4250,0.4170,0.6240,0.5790,0.5550,0.5350,0.5280, 0.7450,0.7140,0.6780,0.6760,0.6720,0.7520,0.7230,0.6980,0.6850,0.6820,0.85,0.81,0.8,0.8,0.8}

static

Definition at line 263 of file main.c.

Referenced by cdEvaluation(), optimalAngle(), and StartMPC_Task().

cpy_buffer

uint8_t cpy_buffer[2112] = {0}

Definition at line 310 of file main.c.

Referenced by StartKalman_mkf().

current_delta

double current_delta = 0

Definition at line 257 of file main.c.

Referenced by optimalAngle().

data_buffer

uint8_t data_buffer[4224] ={0}

Definition at line 309 of file main.c.

Referenced by StartKalman_mkf(), and StartSensor_Task().

data_raw_acceleration_1

int16_t data_raw_acceleration_1[3] = {0}

static

Definition at line 130 of file main.c.

Referenced by StartSensor_Task().

data_raw_angular_rate_1

int16_t data_raw_angular_rate_1[3] = {0}

static

Definition at line 129 of file main.c.

Referenced by StartSensor_Task().

deployment_states

const double deployment_states[] ={0.0,40.5000,69.7500,94.5000,108.0000,173.8000}

Definition at line 262 of file main.c.

Referenced by optimalAngle(), and StartMPC_Task().

first_measure

bool first_measure = true

Definition at line 233 of file main.c.

Referenced by StartSensor_Task().

flash_address

uint32_t flash_address = 4

Definition at line 308 of file main.c.

Referenced by StartKalman_mkf().

flight_phase

flight_phase_t flight_phase = CALIBRATING

Definition at line 115 of file main.c.

Referenced by main().

flight_state

flight_fsm_t flight_state

Definition at line 117 of file main.c.

Referenced by main(), StartFSM(), StartMPC_Task(), and StartSensor_Task().

FSM_attributes

const osThreadAttr_t FSM_attributes

Initial value:

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

Definition at line 87 of file main.c.

Referenced by main().

FSMHandle

osThreadId_t FSMHandle

Definition at line 86 of file main.c.

Referenced by HAL_TIM_PeriodElapsedCallback(), and main().

gnss_flag

bool gnss_flag = false

Definition at line 300 of file main.c.

Referenced by StartKalman_mkf(), and StartReceiveVel_Task().

gps_vel

float gps_vel = 0.0f

Definition at line 293 of file main.c.

Referenced by StartKalman_mkf(), StartReceiveVel_Task(), and StartSensor_Task().

hadc1

ADC_HandleTypeDef hadc1

Definition at line 52 of file main.c.

Referenced by MX_ADC1_Init().

hadc2

ADC_HandleTypeDef hadc2

Definition at line 53 of file main.c.

Referenced by MX_ADC2_Init().

hadc3

ADC_HandleTypeDef hadc3

Definition at line 54 of file main.c.

Referenced by MX_ADC3_Init(), and StartMPC_Task().

hdma_usart1_rx

DMA_HandleTypeDef hdma_usart1_rx

Definition at line 73 of file main.c.

Referenced by DMA1_Stream0_IRQHandler(), and HAL_UART_MspInit().

hdma_usart1_tx

DMA_HandleTypeDef hdma_usart1_tx

Definition at line 74 of file main.c.

Referenced by DMA1_Stream1_IRQHandler(), and HAL_UART_MspInit().

hfdcan1

FDCAN_HandleTypeDef hfdcan1

Definition at line 56 of file main.c.

Referenced by MX_FDCAN1_Init().

hmdma_quadspi_fifo_th

MDMA_HandleTypeDef hmdma_quadspi_fifo_th

Definition at line 59 of file main.c.

Referenced by HAL_QSPI_MspInit(), and MDMA_IRQHandler().

hpcd_USB_OTG_FS

PCD_HandleTypeDef hpcd_USB_OTG_FS

Definition at line 76 of file main.c.

Referenced by MX_USB_OTG_FS_PCD_Init().

hspi1

SPI_HandleTypeDef hspi1

Definition at line 61 of file main.c.

Referenced by MX_SPI1_Init().

htim13

TIM_HandleTypeDef htim13

Definition at line 68 of file main.c.

Referenced by MX_TIM13_Init(), StartFSM(), and TIM8_UP_TIM13_IRQHandler().

htim2

TIM_HandleTypeDef htim2

Definition at line 65 of file main.c.

Referenced by MX_TIM2_Init().

htim6

TIM_HandleTypeDef htim6

Definition at line 66 of file main.c.

Referenced by MX_TIM6_Init(), StartSensor_Task(), and TIM6_DAC_IRQHandler().

htim7

TIM_HandleTypeDef htim7

Definition at line 67 of file main.c.

Referenced by MX_TIM7_Init(), StartMPC_Task(), and TIM7_IRQHandler().

huart1

UART_HandleTypeDef huart1

Definition at line 72 of file main.c.

Referenced by HAL_TIM_PeriodElapsedCallback(), MX_USART1_UART_Init(), StartMPC_Task(), StartReceiveVel_Task(), and USART1_IRQHandler().

huart4

UART_HandleTypeDef huart4

Definition at line 71 of file main.c.

Referenced by MX_UART4_Init().

imu_1

stmdev_ctx_t imu_1 = {0}

Definition at line 124 of file main.c.

Referenced by main(), and StartSensor_Task().

imu_2

stmdev_ctx_t imu_2 = {0}

Definition at line 124 of file main.c.

Referenced by main().

initial_flag_value

float initial_flag_value = 0.0f

Definition at line 316 of file main.c.

Referenced by main().

Kalman_mkf_attributes

const osThreadAttr_t Kalman_mkf_attributes

Initial value:

= {
  .name = "Kalman_mkf",
  .stack_size = 512 * 4,
  .priority = (osPriority_t) osPriorityNormal,
}

Definition at line 94 of file main.c.

Referenced by main().

Kalman_mkfHandle

osThreadId_t Kalman_mkfHandle

Definition at line 93 of file main.c.

Referenced by main(), and StartSensor_Task().

lis2mdl_dev_ctx

stmdev_ctx_t lis2mdl_dev_ctx

Definition at line 135 of file main.c.

lis2mdl_dev_ctx_2

stmdev_ctx_t lis2mdl_dev_ctx_2

Definition at line 136 of file main.c.

mach_states

const double mach_states[] = {0.1,0.2,0.3,0.4,0.5}

Definition at line 261 of file main.c.

Referenced by cdEvaluation(), optimalAngle(), and StartMPC_Task().

max_alt

float max_alt = 0

Definition at line 231 of file main.c.

Referenced by StartMPC_Task().

max_vel

float max_vel =0

Definition at line 232 of file main.c.

Referenced by StartMPC_Task().

message

Data_Package_For_Marconi message = {0}

Definition at line 228 of file main.c.

Referenced by StartMPC_Task().

MPC_Task_attributes

const osThreadAttr_t MPC_Task_attributes

Initial value:

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

Definition at line 101 of file main.c.

Referenced by main().

MPC_TaskHandle

osThreadId_t MPC_TaskHandle

Definition at line 100 of file main.c.

Referenced by HAL_TIM_PeriodElapsedCallback(), and main().

num_of_lin_acc_saved

uint32_t num_of_lin_acc_saved = 0

Definition at line 311 of file main.c.

Referenced by StartSensor_Task().

num_of_lin_acc_saved_flash

uint32_t num_of_lin_acc_saved_flash = 0

Definition at line 314 of file main.c.

Referenced by StartKalman_mkf().

num_of_saved_rest_packages

uint32_t num_of_saved_rest_packages = 0

Definition at line 312 of file main.c.

Referenced by StartSensor_Task().

num_of_saved_rest_packages_flash

uint32_t num_of_saved_rest_packages_flash = 0

Definition at line 315 of file main.c.

Referenced by StartKalman_mkf().

num_of_saved_rest_packages_locked

uint32_t num_of_saved_rest_packages_locked = 0

Definition at line 313 of file main.c.

Referenced by StartKalman_mkf(), and StartSensor_Task().

omega

double omega[] = {3.760494829166693e-05, -1.4118446451604494e-07, 0.0003572545679652845}

Definition at line 240 of file main.c.

Referenced by mekf(), StartKalman_mkf(), and StartSensor_Task().

P_2

double P_2[] = {5,0,0,5}

Definition at line 247 of file main.c.

Referenced by StartKalman_mkf().

Partition

note_t Partition[]

Initial value:

= {{NOTE_Gb5,TEMPO_BASE_MS*2}, {NOTE_Gb5,TEMPO_BASE_MS},{NOTE_D6,TEMPO_BASE_MS},{NOTE_Db6,TEMPO_BASE_MS*2},
        {NOTE_Db6,TEMPO_BASE_MS*2},{NOTE_Db6,TEMPO_BASE_MS},{NOTE_D6,TEMPO_BASE_MS},{NOTE_B5,TEMPO_BASE_MS*2},
        {NOTE_B5,TEMPO_BASE_MS*2},{NOTE_B5,TEMPO_BASE_MS},{NOTE_A5,TEMPO_BASE_MS},{NOTE_B5,TEMPO_BASE_MS*2},{NOTE_B5,TEMPO_BASE_MS*2},{NOTE_B5,TEMPO_BASE_MS},{NOTE_A5,TEMPO_BASE_MS},{NOTE_B5,TEMPO_BASE_MS},{NOTE_A5,TEMPO_BASE_MS},{NOTE_Gb5,TEMPO_BASE_MS*5}  }

Definition at line 365 of file main.c.

Referenced by main().

Pressure_1

float_t Pressure_1 = 0.0

Definition at line 226 of file main.c.

Referenced by StartSensor_Task().

q

double q[] = {0.7061377159181262, -0.03700710955926802, 0.03700710955926802, -0.7061377159181262}

Definition at line 237 of file main.c.

Referenced by mekf(), and StartKalman_mkf().

Q

const double Q[] = {2769,1846,1846,1385}

Definition at line 252 of file main.c.

Referenced by kalmanFilter(), mekf(), and StartKalman_mkf().

q_new

double q_new[] = {0,0,0,0}

Definition at line 243 of file main.c.

Referenced by mekf(), and StartKalman_mkf().

R

const double R[] = {5.54e-3,0,0,0.121}

Definition at line 253 of file main.c.

Referenced by kalmanFilter(), mekf(), and StartKalman_mkf().

raw_mag_data

int16_t raw_mag_data[3]

Definition at line 137 of file main.c.

ReceiveVel_Task_attributes

const osThreadAttr_t ReceiveVel_Task_attributes

Initial value:

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

Definition at line 108 of file main.c.

Referenced by main().

ReceiveVel_TaskHandle

osThreadId_t ReceiveVel_TaskHandle

Definition at line 107 of file main.c.

Referenced by HAL_UART_ErrorCallback(), HAL_UART_RxCpltCallback(), and main().

Sensor_Task_attributes

const osThreadAttr_t Sensor_Task_attributes

Initial value:

= {
  .name = "Sensor_Task",
  .stack_size = 128 * 4,
  .priority = (osPriority_t) osPriorityRealtime7,
}

Definition at line 80 of file main.c.

Referenced by main().

Sensor_TaskHandle

osThreadId_t Sensor_TaskHandle

Definition at line 79 of file main.c.

Referenced by HAL_TIM_PeriodElapsedCallback(), and main().

sim_time_step

double sim_time_step = 0.5

Definition at line 256 of file main.c.

Referenced by optimalAngle(), and StartMPC_Task().

target_apogee

double target_apogee = 8900

Definition at line 258 of file main.c.

Referenced by optimalAngle(), and StartMPC_Task().

Temperature_1

float_t Temperature_1 = 0.0

Definition at line 227 of file main.c.

Referenced by StartSensor_Task().

tilt_angle

double tilt_angle = 0.24556997475102937

Definition at line 260 of file main.c.

Referenced by optimalAngle().

time_step

double time_step = 0.5

Definition at line 255 of file main.c.

tolerance

double tolerance = 1

Definition at line 259 of file main.c.

Referenced by optimalAngle(), and StartMPC_Task().

Ts

double Ts = 0.01

Definition at line 251 of file main.c.

Referenced by kalmanFilter(), and StartKalman_mkf().

vel

uint8_t vel[4]

Definition at line 292 of file main.c.

Referenced by StartReceiveVel_Task().

velocity

float_t velocity = 0.0

Definition at line 225 of file main.c.

Referenced by optimalAngle(), StartFSM(), StartKalman_mkf(), StartMPC_Task(), and StartSensor_Task().

Vin

float Vin =0

Definition at line 321 of file main.c.

Referenced by StartMPC_Task().

Vr

float Vr =0

Definition at line 322 of file main.c.

Referenced by StartMPC_Task().

x_est

double x_est[] = {5000,330}

Definition at line 254 of file main.c.

Referenced by kalmanFilter(), StartKalman_mkf(), and StartMPC_Task().

xKalman_TaskHandle

TaskHandle_t xKalman_TaskHandle = NULL

Definition at line 271 of file main.c.

xKalman_TaskID

osThreadId_t xKalman_TaskID = NULL

Definition at line 278 of file main.c.

xMPCTaskHandle

TaskHandle_t xMPCTaskHandle = NULL

Definition at line 269 of file main.c.

xMPCTaskID

osThreadId_t xMPCTaskID = NULL

Definition at line 276 of file main.c.

xReceived_VelHandle

TaskHandle_t xReceived_VelHandle = NULL

Definition at line 268 of file main.c.

xReceived_VelID

osThreadId_t xReceived_VelID =NULL

Definition at line 275 of file main.c.

xSensorsTaskHandle

TaskHandle_t xSensorsTaskHandle = NULL

Definition at line 270 of file main.c.

xSensorsTaskID

osThreadId_t xSensorsTaskID = NULL

Definition at line 277 of file main.c.

z

double z[] = {5003.24140978,329.14706741}

Definition at line 248 of file main.c.

Referenced by kalmanFilter(), StartKalman_mkf(), and StartSensor_Task().

z_component

double z_component = 0.0

Definition at line 264 of file main.c.