main.c File Reference

: Main program body More...

#include "main.h"
#include "cmsis_os.h"
#include "fatfs.h"
#include "lwip.h"
#include "usb_device.h"
#include "usb_host.h"
#include "app.h"
#include "dbg.h"
#include "diag.h"
#include "timer_defaults.h"
#include "lwsapi.h"
#include "thread_measurement.h"
#include "uartslave.h"
#include "putslave.h"

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_I2C1_Init (void)
	I2C1 Initialization Function. More...
static void	MX_IWDG_Init (void)
	IWDG Initialization Function. More...
static void	MX_ADC1_Init (void)
	ADC1 Initialization Function. More...
static void	MX_USART1_UART_Init (void)
	USART1 Initialization Function. More...
static void	MX_TIM1_Init (void)
	TIM1 Initialization Function. More...
static void	MX_TIM3_Init (void)
	TIM3 Initialization Function. More...
static void	MX_SPI2_Init (void)
	SPI2 Initialization Function. More...
static void	MX_USART2_UART_Init (void)
	USART2 Initialization Function. More...
static void	MX_USART6_UART_Init (void)
	USART6 Initialization Function. More...
static void	MX_SPI3_Init (void)
	SPI3 Initialization Function. More...
static void	MX_TIM2_Init (void)
	TIM2 Initialization Function. More...
static void	MX_TIM14_Init (void)
	TIM14 Initialization Function. More...
void	StartDefaultTask (void const *argument)
	Function implementing the defaultTask thread. More...
void	StartDisplayTask (void const *argument)
	Function implementing the displayTask thread. More...
void	StartIdleTask (void const *argument)
	Function implementing the idleTask thread. More...
void	StartWebServerTask (void const *argument)
	Function implementing the webServerTask thread. More...
void	gui_run (void)
void	Error_Handler (void)
	This function is executed in case of error occurrence. More...
int	main (void)
	The application entry point. More...
void	st7789v_spi_tx_complete (void)
void	HAL_SPI_TxCpltCallback (SPI_HandleTypeDef *hspi)
void	HAL_UART_RxCpltCallback (UART_HandleTypeDef *huart)
void	HAL_GPIO_EXTI_Callback (uint16_t GPIO_Pin)
void	HAL_TIM_PeriodElapsedCallback (TIM_HandleTypeDef *htim)
	Period elapsed callback in non blocking mode. More...

Variables
ADC_HandleTypeDef	hadc1
I2C_HandleTypeDef	hi2c1
IWDG_HandleTypeDef	hiwdg
SPI_HandleTypeDef	hspi2
SPI_HandleTypeDef	hspi3
DMA_HandleTypeDef	hdma_spi2_tx
TIM_HandleTypeDef	htim1
TIM_HandleTypeDef	htim2
TIM_HandleTypeDef	htim3
TIM_HandleTypeDef	htim14
static UART_HandleTypeDef	huart1
UART_HandleTypeDef	huart2
UART_HandleTypeDef	huart6
DMA_HandleTypeDef	hdma_usart1_rx
DMA_HandleTypeDef	hdma_usart2_rx
DMA_HandleTypeDef	hdma_usart6_rx
osThreadId	defaultTaskHandle
osThreadId	displayTaskHandle
osThreadId	idleTaskHandle
osThreadId	webServerTaskHandle
osThreadId	measurementTaskHandle
int	HAL_IWDG_Reset = 0
int	HAL_GPIO_Initialized = 0
int	HAL_ADC_Initialized = 0
int	HAL_PWM_Initialized = 0
int	HAL_SPI_Initialized = 0
uartrxbuff_t	uart1rxbuff
static uint8_t	uart1rx_data [200]
uartrxbuff_t	uart6rxbuff
uint8_t	uart6rx_data [32]
uartslave_t	uart6slave
char	uart6slave_line [32]
uint32_t	Tacho_FAN0
uint32_t	Tacho_FAN1

Detailed Description

: Main program body

This notice applies to any and all portions of this file that are not between comment pairs USER CODE BEGIN and USER CODE END. Other portions of this file, whether inserted by the user or by software development tools are owned by their respective copyright owners.

COPYRIGHT(c) 2019 STMicroelectronics

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of STMicroelectronics nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Function Documentation

SystemClock_Config()

void SystemClock_Config

(

void

)

System Clock Configuration.

Return values

None

Configure the main internal regulator output voltage

Initializes the CPU, AHB and APB busses clocks

Initializes the CPU, AHB and APB busses clocks

                              {
    RCC_OscInitTypeDef RCC_OscInitStruct = { 0 };
    RCC_ClkInitTypeDef RCC_ClkInitStruct = { 0 };
 
    /**Configure the main internal regulator output voltage
  */
    __HAL_RCC_PWR_CLK_ENABLE();
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
    /**Initializes the CPU, AHB and APB busses clocks
  */
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_HSE;
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    RCC_OscInitStruct.LSIState = RCC_LSI_ON;
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    RCC_OscInitStruct.PLL.PLLM = 6;
    RCC_OscInitStruct.PLL.PLLN = 168;
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    RCC_OscInitStruct.PLL.PLLQ = 7;
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
        Error_Handler();
    }
    /**Initializes the CPU, AHB and APB busses clocks
  */
    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_DIV4;
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
 
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK) {
        Error_Handler();
    }
}

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

                               {
    GPIO_InitTypeDef GPIO_InitStruct = { 0 };
 
    /* GPIO Ports Clock Enable */
    __HAL_RCC_GPIOE_CLK_ENABLE();
    __HAL_RCC_GPIOC_CLK_ENABLE();
    __HAL_RCC_GPIOH_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(USB_EN_GPIO_Port, USB_EN_Pin, GPIO_PIN_RESET);
 
    /*Configure GPIO pin Output Level */
    HAL_GPIO_WritePin(GPIOC, ESP_RST_Pin | LCD_RST_Pin | LCD_CS_Pin, GPIO_PIN_RESET);
 
    /*Configure GPIO pin Output Level */
    HAL_GPIO_WritePin(GPIOD, E_DIR_Pin | E_STEP_Pin | E_ENA_Pin | LCD_RS_Pin | Y_DIR_Pin | Y_STEP_Pin | Y_ENA_Pin | Z_DIR_Pin | X_DIR_Pin | X_STEP_Pin | Z_ENA_Pin | X_ENA_Pin | Z_STEP_Pin | FLASH_CSN_Pin, GPIO_PIN_RESET);
 
    /*Configure GPIO pins : X_DIAG_Pin Z_DIAG_Pin USB_OVERC_Pin ESP_GPIO0_Pin
                           BED_MON_Pin WP1_Pin Z_DIAGE1_Pin */
    GPIO_InitStruct.Pin = X_DIAG_Pin | Z_DIAG_Pin | USB_OVERC_Pin | ESP_GPIO0_Pin
        | BED_MON_Pin | WP1_Pin | Z_DIAGE1_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
    /*Configure GPIO pin : USB_EN_Pin */
    GPIO_InitStruct.Pin = USB_EN_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(USB_EN_GPIO_Port, &GPIO_InitStruct);
 
    /*Configure GPIO pins : ESP_RST_Pin LCD_RST_Pin LCD_CS_Pin */
    GPIO_InitStruct.Pin = ESP_RST_Pin | LCD_RST_Pin | LCD_CS_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);
 
    /*Configure GPIO pins : FAN0_TACH_Pin FAN1_TACH_Pin */
    GPIO_InitStruct.Pin = FAN0_TACH_Pin | FAN1_TACH_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
    /*Configure GPIO pins : LCD_SW1_Pin LCD_SW3_Pin LCD_SW2_Pin */
    GPIO_InitStruct.Pin = LCD_SW1_Pin | LCD_SW3_Pin | LCD_SW2_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
 
    /*Configure GPIO pins : E_DIR_Pin E_STEP_Pin E_ENA_Pin LCD_RS_Pin
                           Y_DIR_Pin Y_STEP_Pin Y_ENA_Pin Z_DIR_Pin
                           X_DIR_Pin X_STEP_Pin Z_ENA_Pin X_ENA_Pin
                           Z_STEP_Pin FLASH_CSN_Pin */
    GPIO_InitStruct.Pin = E_DIR_Pin | E_STEP_Pin | E_ENA_Pin | LCD_RS_Pin
        | Y_DIR_Pin | Y_STEP_Pin | Y_ENA_Pin | Z_DIR_Pin
        | X_DIR_Pin | X_STEP_Pin | Z_ENA_Pin | X_ENA_Pin
        | Z_STEP_Pin | FLASH_CSN_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 pin : Z_MIN_Pin */
    GPIO_InitStruct.Pin = Z_MIN_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_PULLUP;
    HAL_GPIO_Init(Z_MIN_GPIO_Port, &GPIO_InitStruct);
 
    /*Configure GPIO pin : E_DIAG_Pin */
    GPIO_InitStruct.Pin = E_DIAG_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(E_DIAG_GPIO_Port, &GPIO_InitStruct);
 
    /*Configure GPIO pins : FIL_SENSOR_Pin WP2_Pin */
    GPIO_InitStruct.Pin = FIL_SENSOR_Pin | WP2_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
 
    /* EXTI interrupt init*/
    HAL_NVIC_SetPriority(EXTI15_10_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}

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

                              {
    /* DMA controller clock enable */
    __HAL_RCC_DMA1_CLK_ENABLE();
    __HAL_RCC_DMA2_CLK_ENABLE();
 
    /* DMA interrupt init */
    /* DMA1_Stream4_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA1_Stream4_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream4_IRQn);
    /* DMA1_Stream5_IRQn interrupt configuration */
    HAL_NVIC_SetPriority(DMA1_Stream5_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(DMA1_Stream5_IRQn);
    /* 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 call graph for this function:

Here is the caller graph for this function:

MX_I2C1_Init()

static void MX_I2C1_Init ( void  )

static

I2C1 Initialization Function.

Parameters

None

Return values

None

                               {
 
    /* USER CODE BEGIN I2C1_Init 0 */
 
    /* USER CODE END I2C1_Init 0 */
 
    /* USER CODE BEGIN I2C1_Init 1 */
 
    /* USER CODE END I2C1_Init 1 */
    hi2c1.Instance = I2C1;
    hi2c1.Init.ClockSpeed = 100000;
    hi2c1.Init.DutyCycle = I2C_DUTYCYCLE_2;
    hi2c1.Init.OwnAddress1 = 0;
    hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
    hi2c1.Init.OwnAddress2 = 0;
    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
    hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
    if (HAL_I2C_Init(&hi2c1) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN I2C1_Init 2 */
 
    /* USER CODE END I2C1_Init 2 */
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_IWDG_Init()

static void MX_IWDG_Init ( void  )

static

IWDG Initialization Function.

Parameters

None

Return values

None

                               {
 
    /* USER CODE BEGIN IWDG_Init 0 */
 
    /* USER CODE END IWDG_Init 0 */
 
    /* USER CODE BEGIN IWDG_Init 1 */
    //Watchdog is enable in marlin init
#if 0
  /* USER CODE END IWDG_Init 1 */
  hiwdg.Instance = IWDG;
  hiwdg.Init.Prescaler = IWDG_PRESCALER_4;
  hiwdg.Init.Reload = 4095;
  if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN IWDG_Init 2 */
#endif
    /* USER CODE END IWDG_Init 2 */
}

Here is the call graph for this function:

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

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.

                               {
 
    /* 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 */
    /**Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
  */
    hadc1.Instance = ADC1;
    hadc1.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
    hadc1.Init.Resolution = ADC_RESOLUTION_12B;
    hadc1.Init.ScanConvMode = DISABLE;
    hadc1.Init.ContinuousConvMode = DISABLE;
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
    hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion = 1;
    hadc1.Init.DMAContinuousRequests = DISABLE;
    hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
    if (HAL_ADC_Init(&hadc1) != HAL_OK) {
        Error_Handler();
    }
    /**Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
  */
    sConfig.Channel = ADC_CHANNEL_4;
    sConfig.Rank = 1;
    sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
    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_USART1_UART_Init()

static void MX_USART1_UART_Init ( void  )

static

USART1 Initialization Function.

Parameters

None

Return values

None

                                      {
 
    /* 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 = 115200;
    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;
    if (HAL_UART_Init(&huart1) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN USART1_Init 2 */
 
    /* USER CODE END USART1_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

                               {
 
    /* USER CODE BEGIN TIM1_Init 0 */
 
    /* USER CODE END TIM1_Init 0 */
 
    TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
    TIM_MasterConfigTypeDef sMasterConfig = { 0 };
    TIM_OC_InitTypeDef sConfigOC = { 0 };
    TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = { 0 };
 
    /* USER CODE BEGIN TIM1_Init 1 */
 
    /* USER CODE END TIM1_Init 1 */
    htim1.Instance = TIM1;
    htim1.Init.Prescaler = TIM1_default_Prescaler; //0x3fff was 100;
    htim1.Init.CounterMode = TIM_COUNTERMODE_DOWN;
    htim1.Init.Period = TIM1_default_Period; //0xff was 42000;
    htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    htim1.Init.RepetitionCounter = 0;
    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();
    }
    if (HAL_TIM_PWM_Init(&htim1) != HAL_OK) {
        Error_Handler();
    }
    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK) {
        Error_Handler();
    }
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = 0;
    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(&htim1, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) {
        Error_Handler();
    }
    if (HAL_TIM_PWM_ConfigChannel(&htim1, &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.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
    if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN TIM1_Init 2 */
    //HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_1);
    //HAL_TIM_PWM_Start(&htim1,TIM_CHANNEL_2);
    /* USER CODE END TIM1_Init 2 */
    HAL_TIM_MspPostInit(&htim1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM3_Init()

static void MX_TIM3_Init ( void  )

static

TIM3 Initialization Function.

Parameters

None

Return values

None

                               {
 
    /* USER CODE BEGIN TIM3_Init 0 */
 
    /* USER CODE END TIM3_Init 0 */
 
    TIM_ClockConfigTypeDef sClockSourceConfig = { 0 };
    TIM_MasterConfigTypeDef sMasterConfig = { 0 };
    TIM_OC_InitTypeDef sConfigOC = { 0 };
 
    /* USER CODE BEGIN TIM3_Init 1 */
 
    /* USER CODE END TIM3_Init 1 */
    htim3.Instance = TIM3;
    htim3.Init.Prescaler = TIM3_default_Prescaler; //0x3fff was 100
    htim3.Init.CounterMode = TIM_COUNTERMODE_DOWN;
    htim3.Init.Period = TIM3_default_Period; //0xff was 42000
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    if (HAL_TIM_Base_Init(&htim3) != HAL_OK) {
        Error_Handler();
    }
    sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
    if (HAL_TIM_ConfigClockSource(&htim3, &sClockSourceConfig) != HAL_OK) {
        Error_Handler();
    }
    if (HAL_TIM_PWM_Init(&htim3) != HAL_OK) {
        Error_Handler();
    }
    sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
    sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
    if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK) {
        Error_Handler();
    }
    sConfigOC.OCMode = TIM_OCMODE_PWM1;
    sConfigOC.Pulse = 21000;
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_3) != HAL_OK) {
        Error_Handler();
    }
    if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN TIM3_Init 2 */
    //HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_3);
    //HAL_TIM_PWM_Start(&htim3,TIM_CHANNEL_4);
    /* USER CODE END TIM3_Init 2 */
    HAL_TIM_MspPostInit(&htim3);
}

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

                               {
 
    /* 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_LOW;
    hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi2.Init.NSS = SPI_NSS_SOFT;
    hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
    hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi2.Init.CRCPolynomial = 10;
    if (HAL_SPI_Init(&hspi2) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN SPI2_Init 2 */
 
    /* USER CODE END SPI2_Init 2 */
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_USART2_UART_Init()

static void MX_USART2_UART_Init ( void  )

static

USART2 Initialization Function.

Parameters

None

Return values

None

                                      {
 
    /* USER CODE BEGIN USART2_Init 0 */
 
    /* USER CODE END USART2_Init 0 */
 
    /* USER CODE BEGIN USART2_Init 1 */
 
    /* USER CODE END USART2_Init 1 */
    huart2.Instance = USART2;
    huart2.Init.BaudRate = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits = UART_STOPBITS_1;
    huart2.Init.Parity = UART_PARITY_NONE;
    huart2.Init.Mode = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart2) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN USART2_Init 2 */
 
    /* USER CODE END USART2_Init 2 */
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_USART6_UART_Init()

static void MX_USART6_UART_Init ( void  )

static

USART6 Initialization Function.

Parameters

None

Return values

None

                                      {
 
    /* USER CODE BEGIN USART6_Init 0 */
 
    /* USER CODE END USART6_Init 0 */
 
    /* USER CODE BEGIN USART6_Init 1 */
 
    /* USER CODE END USART6_Init 1 */
    huart6.Instance = USART6;
    huart6.Init.BaudRate = 115200;
    huart6.Init.WordLength = UART_WORDLENGTH_8B;
    huart6.Init.StopBits = UART_STOPBITS_1;
    huart6.Init.Parity = UART_PARITY_NONE;
    huart6.Init.Mode = UART_MODE_TX_RX;
    huart6.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    huart6.Init.OverSampling = UART_OVERSAMPLING_16;
    if (HAL_UART_Init(&huart6) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN USART6_Init 2 */
 
    /* USER CODE END USART6_Init 2 */
}

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

                               {
 
    /* 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_LOW;
    hspi3.Init.CLKPhase = SPI_PHASE_1EDGE;
    hspi3.Init.NSS = SPI_NSS_SOFT;
    hspi3.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
    hspi3.Init.FirstBit = SPI_FIRSTBIT_MSB;
    hspi3.Init.TIMode = SPI_TIMODE_DISABLE;
    hspi3.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
    hspi3.Init.CRCPolynomial = 10;
    if (HAL_SPI_Init(&hspi3) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN SPI3_Init 2 */
 
    /* USER CODE END SPI3_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

                               {
 
    /* USER CODE BEGIN TIM2_Init 0 */
 
    /* USER CODE END TIM2_Init 0 */
 
    TIM_ClockConfigTypeDef sClockSourceConfig = { 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 = 100;
    htim2.Init.CounterMode = TIM_COUNTERMODE_DOWN;
    htim2.Init.Period = 42000;
    htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    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();
    }
    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 = 21000;
    sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN TIM2_Init 2 */
 
    /* USER CODE END TIM2_Init 2 */
    HAL_TIM_MspPostInit(&htim2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MX_TIM14_Init()

static void MX_TIM14_Init ( void  )

static

TIM14 Initialization Function.

Parameters

None

Return values

None

                                {
 
    /* USER CODE BEGIN TIM14_Init 0 */
 
    /* USER CODE END TIM14_Init 0 */
 
    /* USER CODE BEGIN TIM14_Init 1 */
 
    /* USER CODE END TIM14_Init 1 */
    htim14.Instance = TIM14;
    htim14.Init.Prescaler = 84;
    htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
    htim14.Init.Period = 1000;
    htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    if (HAL_TIM_Base_Init(&htim14) != HAL_OK) {
        Error_Handler();
    }
    /* USER CODE BEGIN TIM14_Init 2 */
    HAL_TIM_Base_Start_IT(&htim14);
    /* USER CODE END TIM14_Init 2 */
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartDefaultTask()

void StartDefaultTask

(

void const *

argument

)

Function implementing the defaultTask thread.

Parameters

argument

Not used

Return values

None

                                            {
    /* init code for USB_DEVICE */
    MX_USB_DEVICE_Init();
 
    /* init code for USB_HOST */
    MX_USB_HOST_Init();
 
    /* init code for FATFS */
    MX_FATFS_Init();
 
    /* init code for LWIP */
    //MX_LWIP_Init();
 
    /* USER CODE BEGIN 5 */
    app_run();
    /* Infinite loop */
    for (;;) {
        osDelay(1);
    }
    /* USER CODE END 5 */
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartDisplayTask()

void StartDisplayTask

(

void const *

argument

)

Function implementing the displayTask thread.

Parameters

argument

Not used

Return values

None

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

Here is the call graph for this function:

Here is the caller graph for this function:

StartIdleTask()

void StartIdleTask

(

void const *

argument

)

Function implementing the idleTask thread.

Parameters

argument

Not used

Return values

None

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

Here is the call graph for this function:

Here is the caller graph for this function:

StartWebServerTask()

void StartWebServerTask

(

void const *

argument

)

Function implementing the webServerTask thread.

Parameters

argument

Not used

Return values

None

                                              {
    /* USER CODE BEGIN StartWebServerTask */
    // osThreadSuspend(0);
    MX_LWIP_Init();
    lwsapi_init();
    /* Infinite loop */
    for (;;) {
        osDelay(1);
    }
    /* USER CODE END StartWebServerTask */
}

Here is the call graph for this function:

Here is the caller graph for this function:

gui_run()

void gui_run

(

void

)

                   {
    if (diag_fastboot)
        return;
 
    st7789v_config = st7789v_cfg;
    jogwheel_config = jogwheel_cfg;
    gui_init();
 
    // select jogwheel type by meassured 'reset delay'
    // original displays with 15 position encoder returns values 1-2 (short delay - no capacitor)
    // new displays with MK3 encoder returns values around 16000 (long delay - 100nF capacitor)
    if (st7789v_reset_delay > 1000) // threshold value is 1000
        jogwheel_config.flg = JOGWHEEL_FLG_INV_DIR;
    //_dbg("delay=%u", st7789v_reset_delay);
 
    gui_defaults.font = resource_font(IDR_FNT_NORMAL);
    gui_defaults.font_big = resource_font(IDR_FNT_BIG);
    window_msgbox_id_icon[0] = 0; //IDR_PNG_icon_pepa;
    window_msgbox_id_icon[1] = IDR_PNG_header_icon_error;
    window_msgbox_id_icon[2] = IDR_PNG_header_icon_question;
    window_msgbox_id_icon[3] = IDR_PNG_header_icon_warning;
    window_msgbox_id_icon[4] = IDR_PNG_header_icon_info;
 
    if (!sys_fw_is_valid())
        update_firmware_screen();
 
    gui_marlin_vars = marlin_client_init();
 
    hwio_beeper_tone2(440.0, 100, 0.0125); //start beep
 
    screen_register(pscreen_splash);
    screen_register(pscreen_watchdog);
 
    WINDOW_CLS_LOGO = window_register_class((window_class_t *)&window_class_logo);
#ifdef LCDSIM
    WINDOW_CLS_LCDSIM = window_register_class((window_class_t *)&window_class_lcdsim);
    screen_register(pscreen_marlin);
#else //LCDSIM
    WINDOW_CLS_FILE_LIST = window_register_class((window_class_t *)&window_class_file_list);
    WINDOW_CLS_HEADER = window_register_class((window_class_t *)&window_class_header);
    WINDOW_CLS_TEMP_GRAPH = window_register_class((window_class_t *)&window_class_temp_graph);
    WINDOW_CLS_DLG_LOADUNLOAD = window_register_class((window_class_t *)&window_class_dlg_statemachine);
    WINDOW_CLS_DLG_WAIT = window_register_class((window_class_t *)&window_class_dlg_wait);
    #ifdef _DEBUG
    WINDOW_CLS_DLG_POPUP = window_register_class((window_class_t *)&window_class_dlg_popup);
    #endif //_DEBUG
    WINDOW_CLS_DLG_PREHEAT = window_register_class((window_class_t *)&window_class_dlg_preheat);
    screen_register(pscreen_test);
    screen_register(pscreen_test_gui);
    screen_register(pscreen_test_term);
    screen_register(pscreen_test_msgbox);
    screen_register(pscreen_test_graph);
    screen_register(pscreen_test_temperature);
    screen_register(pscreen_home);
    screen_register(pscreen_filebrowser);
    screen_register(pscreen_printing);
    screen_register(pscreen_menu_preheat);
    screen_register(pscreen_menu_filament);
    screen_register(pscreen_menu_calibration);
    screen_register(pscreen_menu_settings);
    screen_register(pscreen_menu_temperature);
    screen_register(pscreen_menu_move);
    screen_register(pscreen_menu_info);
    screen_register(pscreen_menu_tune);
    screen_register(pscreen_menu_service);
    screen_register(pscreen_sysinfo);
    screen_register(pscreen_version_info);
    screen_register(pscreen_test_disp_mem);
    screen_register(pscreen_messages);
    #ifdef PIDCALIBRATION
    screen_register(pscreen_PID);
    #endif //PIDCALIBRATION
    screen_register(pscreen_mesh_bed_lv);
    screen_register(pscreen_wizard);
    screen_register(pscreen_print_preview);
    screen_register(pscreen_lan_settings);
    screen_register(pscreen_menu_fw_update);
#endif // LCDSIM
 
#ifndef _DEBUG
    if (HAL_IWDG_Reset) {
        screen_stack_push(pscreen_splash->id);
        screen_open(pscreen_watchdog->id);
    } else
#endif // _DEBUG
        screen_open(pscreen_splash->id);
 
    //set loop callback (will be called every time inside gui_loop)
    gui_loop_cb = marlin_client_loop;
    int8_t gui_timeout_id;
    while (1) {
        float vol = 0.01F;
        //simple jogwheel acoustic feedback
        if ((jogwheel_changed & 1) && jogwheel_button_down) //button changed and pressed
            hwio_beeper_tone2(200.0, 50, (double)(vol * 0.125F)); //beep
        else if (jogwheel_changed & 2) // encoder changed
            hwio_beeper_tone2(50.0, 25, (double)(vol * 0.125F)); //short click
        // show warning dialog on safety timer expiration
        if (marlin_event_clr(MARLIN_EVT_SafetyTimerExpired)) {
            gui_msgbox("Heating disabled due to 30 minutes of inactivity.", MSGBOX_BTN_OK | MSGBOX_ICO_WARNING);
        }
        gui_loop();
#ifndef LCDSIM
        if (marlin_message_received()) {
            screen_t *curr = screen_get_curr();
            if (curr == pscreen_printing) {
                screen_dispatch_event(NULL, WINDOW_EVENT_MESSAGE, 0);
            }
        }
        if (menu_timeout_enabled) {
            gui_timeout_id = gui_get_menu_timeout_id();
            if (gui_timer_expired(gui_timeout_id) == 1) {
                screen_t *curr = screen_get_curr();
                if (
                    curr != pscreen_menu_tune && curr != pscreen_wizard && curr != pscreen_print_preview) { //timeout screen black list
    #ifdef PIDCALIBRATION
                    if (curr != pscreen_PID) {
    #endif //PIDCALIBRATION
                        while (curr != pscreen_printing && curr != pscreen_home && curr != pscreen_menu_tune) {
                            screen_close();
                            curr = screen_get_curr();
                        }
    #ifdef PIDCALIBRATION
                    }
    #endif //PIDCALIBRATION
                }
                gui_timer_delete(gui_timeout_id);
            }
        }
        if (marlin_event_clr(MARLIN_EVT_CommandBegin)) {
            if (marlin_command() == MARLIN_CMD_M600) {
                _dbg("M600 start");
                gui_dlg_change();
                _dbg("M600 end");
            }
        }
#endif //LCDSIM
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Error_Handler()

void Error_Handler

(

void

)

This function is executed in case of error occurrence.

Return values

None

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

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

void

)

The application entry point.

Return values

int

               {
    /* USER CODE BEGIN 1 */
 
    /*
#define RCC_FLAG_LSIRDY                  ((uint8_t)0x61)
#define RCC_FLAG_BORRST                  ((uint8_t)0x79)
#define RCC_FLAG_PINRST                  ((uint8_t)0x7A)
#define RCC_FLAG_PORRST                  ((uint8_t)0x7B)
#define RCC_FLAG_SFTRST                  ((uint8_t)0x7C)
#define RCC_FLAG_IWDGRST                 ((uint8_t)0x7D)
#define RCC_FLAG_WWDGRST                 ((uint8_t)0x7E)
#define RCC_FLAG_LPWRRST                 ((uint8_t)0x7F)
*/
 
    //__HAL_RCC_GET_FLAG(RCC_FLAG_LPWRRST);
    //__HAL_RCC_GET_FLAG(RCC_FLAG_WWDGRST);
    if (__HAL_RCC_GET_FLAG(RCC_FLAG_IWDGRST))
        HAL_IWDG_Reset = 1;
    //__HAL_RCC_GET_FLAG(RCC_FLAG_SFTRST);
    //__HAL_RCC_GET_FLAG(RCC_FLAG_PORRST);
    //__HAL_RCC_GET_FLAG(RCC_FLAG_PINRST);
    //__HAL_RCC_GET_FLAG(RCC_FLAG_BORRST);
    __HAL_RCC_CLEAR_RESET_FLAGS();
 
    /* 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 */
 
    diag_check_fastboot();
 
    /* USER CODE END SysInit */
 
    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_I2C1_Init();
    MX_IWDG_Init();
    MX_ADC1_Init();
    MX_USART1_UART_Init();
    MX_TIM1_Init();
    MX_TIM3_Init();
    MX_SPI2_Init();
    MX_USART2_UART_Init();
    MX_USART6_UART_Init();
    MX_SPI3_Init();
    MX_TIM2_Init();
    MX_TIM14_Init();
    /* USER CODE BEGIN 2 */
    HAL_GPIO_Initialized = 1;
    HAL_ADC_Initialized = 1;
    HAL_PWM_Initialized = 1;
    HAL_SPI_Initialized = 1;
 
    uartrxbuff_init(&uart1rxbuff, &huart1, &hdma_usart1_rx, sizeof(uart1rx_data), uart1rx_data);
    uartrxbuff_open(&uart1rxbuff);
 
    uartrxbuff_init(&uart6rxbuff, &huart6, &hdma_usart6_rx, sizeof(uart6rx_data), uart6rx_data);
    uartrxbuff_open(&uart6rxbuff);
    uartslave_init(&uart6slave, &uart6rxbuff, sizeof(uart6slave_line), uart6slave_line);
    putslave_init(&uart6slave);
 
    /* USER CODE END 2 */
 
    /* 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 */
 
    /* Create the thread(s) */
    /* definition and creation of defaultTask */
    osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 1024);
    defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
 
    /* definition and creation of displayTask */
    osThreadDef(displayTask, StartDisplayTask, osPriorityNormal, 0, 2048);
    displayTaskHandle = osThreadCreate(osThread(displayTask), NULL);
 
    /* definition and creation of idleTask */
    osThreadDef(idleTask, StartIdleTask, osPriorityIdle, 0, 128);
    idleTaskHandle = osThreadCreate(osThread(idleTask), NULL);
 
    /* definition and creation of webServerTask */
    osThreadDef(webServerTask, StartWebServerTask, osPriorityNormal, 0, 4096);
    webServerTaskHandle = osThreadCreate(osThread(webServerTask), NULL);
 
    /* USER CODE BEGIN RTOS_THREADS */
    /* add threads, ... */
    /* definition and creation of measurementTask */
    osThreadDef(measurementTask, StartMeasurementTask, osPriorityNormal, 0, 512);
    measurementTaskHandle = osThreadCreate(osThread(measurementTask), NULL);
    /* USER CODE END RTOS_THREADS */
 
    /* USER CODE BEGIN RTOS_QUEUES */
    /* add queues, ... */
    /* USER CODE END RTOS_QUEUES */
 
    /* 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 */
}

Here is the call graph for this function:

st7789v_spi_tx_complete()

void st7789v_spi_tx_complete

(

void

)

                                   {
#ifdef ST7789V_USE_RTOS
    osSignalSet(st7789v_task_handle, ST7789V_SIG_SPI_TX);
#endif //ST7789V_USE_RTOS
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

hadc1

ADC_HandleTypeDef hadc1

hi2c1

I2C_HandleTypeDef hi2c1

hiwdg

IWDG_HandleTypeDef hiwdg

Marlin 3D Printer Firmware Copyright (c) 2019 MarlinFirmware [https://github.com/MarlinFirmware/Marlin]

Based on Sprinter and grbl. Copyright (c) 2011 Camiel Gubbels / Erik van der Zalm

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

hspi2

SPI_HandleTypeDef hspi2

hspi3

SPI_HandleTypeDef hspi3

hdma_spi2_tx

DMA_HandleTypeDef hdma_spi2_tx

File Name : stm32f4xx_hal_msp.c Description : This file provides code for the MSP Initialization and de-Initialization codes.

This notice applies to any and all portions of this file that are not between comment pairs USER CODE BEGIN and USER CODE END. Other portions of this file, whether inserted by the user or by software development tools are owned by their respective copyright owners.

COPYRIGHT(c) 2019 STMicroelectronics

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. Neither the name of STMicroelectronics nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

htim1

TIM_HandleTypeDef htim1

htim2

TIM_HandleTypeDef htim2

htim3

TIM_HandleTypeDef htim3

htim14

TIM_HandleTypeDef htim14

huart1

UART_HandleTypeDef huart1

static

huart2

UART_HandleTypeDef huart2

huart6

UART_HandleTypeDef huart6

hdma_usart1_rx

DMA_HandleTypeDef hdma_usart1_rx

hdma_usart2_rx

DMA_HandleTypeDef hdma_usart2_rx

hdma_usart6_rx

DMA_HandleTypeDef hdma_usart6_rx

defaultTaskHandle

osThreadId defaultTaskHandle

displayTaskHandle

osThreadId displayTaskHandle

idleTaskHandle

osThreadId idleTaskHandle

webServerTaskHandle

osThreadId webServerTaskHandle

measurementTaskHandle

osThreadId measurementTaskHandle

HAL_IWDG_Reset

int HAL_IWDG_Reset = 0

HAL_GPIO_Initialized

int HAL_GPIO_Initialized = 0

HAL_ADC_Initialized

int HAL_ADC_Initialized = 0

HAL_PWM_Initialized

int HAL_PWM_Initialized = 0

HAL_SPI_Initialized

int HAL_SPI_Initialized = 0

uart1rxbuff

uartrxbuff_t uart1rxbuff

uart1rx_data

uint8_t uart1rx_data[200]

static

uart6rxbuff

uartrxbuff_t uart6rxbuff

uart6rx_data

uint8_t uart6rx_data[32]

uart6slave

uartslave_t uart6slave

uart6slave_line

char uart6slave_line[32]

Tacho_FAN0

uint32_t Tacho_FAN0

Tacho_FAN1

uint32_t Tacho_FAN1