UART receiving issue

Forum|Forum|19 days ago
May 14, 2026
4 replies
284 views

Hello, I was able to successfully implement a way to read motor status and various parameters through UART on putty with my B-G431B-ESC1. However, when I tried following tutorials to add a way to also control the motor status (turning it on and off), I keep getting no response from the motor when I type commands in putty. I don't know if something is wrong with my code or with the way I set up putty, but im leaning more towards the code since the TX part works well. Im quite a beginner with this so maybe its something very ***, but i really cant wrap my head around it. Linked to the post is my main.c. thank you.

STM32G4 Series

Andrew Neil

Super User

Your post is not very clear - please give more details.

See: How to write your question to maximize your chances to find a solution

You forgot to attach your code ?

A complex system that works is invariably found to have evolved from a simple system that worked.A complex system designed from scratch never works and cannot be patched up to make it work.

Da3Author

Associate II

Yep, sorry I forgot to attach my code, here it is

#include "main.h"
#include <stdio.h>
#include <string.h>
#include <mc_config.h>
 
ADC_HandleTypeDef hadc1;
ADC_HandleTypeDef hadc2;
 
COMP_HandleTypeDef hcomp1;
COMP_HandleTypeDef hcomp2;
COMP_HandleTypeDef hcomp4;
 
CORDIC_HandleTypeDef hcordic;
 
DAC_HandleTypeDef hdac3;
 
OPAMP_HandleTypeDef hopamp1;
OPAMP_HandleTypeDef hopamp2;
OPAMP_HandleTypeDef hopamp3;
 
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim4;
 
UART_HandleTypeDef huart2;
DMA_HandleTypeDef hdma_usart2_rx;
DMA_HandleTypeDef hdma_usart2_tx;
 
int velocita = 0;
const char* get_state_name(MCI_State_t state) {
 switch (state) {
 case IDLE: return "IDLE";
 case ALIGNMENT: return "ALIGNMENT";
 case START: return "STARTING";
 case RUN: return "RUNNING";
 case FAULT_NOW: return "FAULT_ACTIVE";
 case FAULT_OVER: return "FAULT_OVER";
 default: return "UNKNOWN";
 }
}
 
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_ADC2_Init(void);
static void MX_COMP1_Init(void);
static void MX_COMP2_Init(void);
static void MX_COMP4_Init(void);
static void MX_CORDIC_Init(void);
static void MX_DAC3_Init(void);
static void MX_OPAMP1_Init(void);
static void MX_OPAMP2_Init(void);
static void MX_OPAMP3_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM4_Init(void);
static void MX_USART2_UART_Init(void);
static void MX_NVIC_Init(void);
 
char msg[128];
uint8_t rx_data[1];
int16_t target_speed = 2500;
 
int main(void)
{
 SystemClock_Config();
 
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_ADC1_Init();
 MX_ADC2_Init();
 MX_COMP1_Init();
 MX_COMP2_Init();
 MX_COMP4_Init();
 MX_CORDIC_Init();
 MX_DAC3_Init();
 MX_OPAMP1_Init();
 MX_OPAMP2_Init();
 MX_OPAMP3_Init();
 MX_TIM1_Init();
 MX_TIM4_Init();
 MX_USART2_UART_Init();
 MX_MotorControl_Init();
 MX_NVIC_Init();
 
 HAL_UART_Receive_IT(&huart2, rx_data, 1);
 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
 {
 
 if (huart->Instance == USART2)
 {
 
 if ((rx_data[0] == 's' || rx_data[0] == 'S') && MC_GetSTMStateMotor1() == IDLE)
 {
 MC_StartMotor1();
 MC_ProgramSpeedRampMotor1(3000, 200);
 }
 else if (rx_data[0] == 'x' || rx_data[0] == 'X')
 {
 MC_StopMotor1();
 }
 
 HAL_UART_Transmit(&huart2, rx_data, 1, 100);
 
 HAL_UART_Receive_IT(&huart2, rx_data, 1);
 }
 
 }
 while (1)
 {
 MCI_State_t currentState = MC_GetSTMStateMotor1();
 if (currentState == FAULT_NOW || currentState == FAULT_OVER)
 {
 MC_AcknowledgeFaultMotor1();
 // HAL_Delay(100);
 }
 velocita = MC_GetMecSpeedAverageMotor1();
 const char* stateName = get_state_name(currentState);
 
 sprintf(msg, "Stato: %s | RPM el: %d | RPM mech: %.1f | Rev counter: %ld\r\n", stateName, velocita*10, velocita/15.5, HALL_M1.RevolutionCounter/155);
 HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), 100);
 HAL_Delay(500);
 
 }
}
 
 
 
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1_BOOST);
 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 = RCC_PLLM_DIV2;
 RCC_OscInitStruct.PLL.PLLN = 85;
 RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV8;
 RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
 RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
 RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_4) != HAL_OK)
 {
 Error_Handler();
 }
 HAL_RCC_EnableCSS();
}
 
static void MX_NVIC_Init(void)
{
 /* USART2_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(USART2_IRQn, 3, 1);
 HAL_NVIC_EnableIRQ(USART2_IRQn);
 /* DMA1_Channel1_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 3, 0);
 HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
 /* TIM1_BRK_TIM15_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(TIM1_BRK_TIM15_IRQn, 4, 1);
 HAL_NVIC_EnableIRQ(TIM1_BRK_TIM15_IRQn);
 /* TIM1_UP_TIM16_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(TIM1_UP_TIM16_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(TIM1_UP_TIM16_IRQn);
 /* ADC1_2_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(ADC1_2_IRQn, 2, 0);
 HAL_NVIC_EnableIRQ(ADC1_2_IRQn);
 /* TIM4_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(TIM4_IRQn, 2, 0);
 HAL_NVIC_EnableIRQ(TIM4_IRQn);
 /* EXTI15_10_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(EXTI15_10_IRQn, 3, 0);
 HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
}
 
static void MX_ADC1_Init(void)
{
 ADC_MultiModeTypeDef multimode = {0};
 ADC_InjectionConfTypeDef sConfigInjected = {0};
 ADC_ChannelConfTypeDef sConfig = {0};
 hadc1.Instance = ADC1;
 hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 hadc1.Init.Resolution = ADC_RESOLUTION_12B;
 hadc1.Init.DataAlign = ADC_DATAALIGN_LEFT;
 hadc1.Init.GainCompensation = 0;
 hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
 hadc1.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
 hadc1.Init.LowPowerAutoWait = DISABLE;
 hadc1.Init.ContinuousConvMode = DISABLE;
 hadc1.Init.NbrOfConversion = 2;
 hadc1.Init.DiscontinuousConvMode = DISABLE;
 hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
 hadc1.Init.DMAContinuousRequests = DISABLE;
 hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
 hadc1.Init.OversamplingMode = DISABLE;
 if (HAL_ADC_Init(&hadc1) != HAL_OK)
 {
 Error_Handler();
 }
 
 multimode.Mode = ADC_MODE_INDEPENDENT;
 if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfigInjected.InjectedChannel = ADC_CHANNEL_3;
 sConfigInjected.InjectedRank = ADC_INJECTED_RANK_1;
 sConfigInjected.InjectedSamplingTime = ADC_SAMPLETIME_6CYCLES_5;
 sConfigInjected.InjectedSingleDiff = ADC_SINGLE_ENDED;
 sConfigInjected.InjectedOffsetNumber = ADC_OFFSET_NONE;
 sConfigInjected.InjectedOffset = 0;
 sConfigInjected.InjectedNbrOfConversion = 2;
 sConfigInjected.InjectedDiscontinuousConvMode = DISABLE;
 sConfigInjected.AutoInjectedConv = DISABLE;
 sConfigInjected.QueueInjectedContext = DISABLE;
 sConfigInjected.ExternalTrigInjecConv = ADC_EXTERNALTRIGINJEC_T1_CC4;
 sConfigInjected.ExternalTrigInjecConvEdge = ADC_EXTERNALTRIGINJECCONV_EDGE_RISING;
 sConfigInjected.InjecOversamplingMode = DISABLE;
 if (HAL_ADCEx_InjectedConfigChannel(&hadc1, &sConfigInjected) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfigInjected.InjectedChannel = ADC_CHANNEL_12;
 sConfigInjected.InjectedRank = ADC_INJECTED_RANK_2;
 if (HAL_ADCEx_InjectedConfigChannel(&hadc1, &sConfigInjected) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfig.Channel = ADC_CHANNEL_1;
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SamplingTime = ADC_SAMPLETIME_47CYCLES_5;
 sConfig.SingleDiff = ADC_SINGLE_ENDED;
 sConfig.OffsetNumber = ADC_OFFSET_NONE;
 sConfig.Offset = 0;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfig.Channel = ADC_CHANNEL_5;
 sConfig.Rank = ADC_REGULAR_RANK_2;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_ADC2_Init(void)
{
 
 ADC_InjectionConfTypeDef sConfigInjected = {0};
 
 hadc2.Instance = ADC2;
 hadc2.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 hadc2.Init.Resolution = ADC_RESOLUTION_12B;
 hadc2.Init.DataAlign = ADC_DATAALIGN_LEFT;
 hadc2.Init.GainCompensation = 0;
 hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE;
 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.DMAContinuousRequests = DISABLE;
 hadc2.Init.Overrun = ADC_OVR_DATA_PRESERVED;
 hadc2.Init.OversamplingMode = DISABLE;
 if (HAL_ADC_Init(&hadc2) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfigInjected.InjectedChannel = ADC_CHANNEL_VOPAMP3_ADC2;
 sConfigInjected.InjectedRank = ADC_INJECTED_RANK_1;
 sConfigInjected.InjectedSamplingTime = ADC_SAMPLETIME_6CYCLES_5;
 sConfigInjected.InjectedSingleDiff = ADC_SINGLE_ENDED;
 sConfigInjected.InjectedOffsetNumber = ADC_OFFSET_NONE;
 sConfigInjected.InjectedOffset = 0;
 sConfigInjected.InjectedNbrOfConversion = 2;
 sConfigInjected.InjectedDiscontinuousConvMode = DISABLE;
 sConfigInjected.AutoInjectedConv = DISABLE;
 sConfigInjected.QueueInjectedContext = DISABLE;
 sConfigInjected.ExternalTrigInjecConv = ADC_EXTERNALTRIGINJEC_T1_CC4;
 sConfigInjected.ExternalTrigInjecConvEdge = ADC_EXTERNALTRIGINJECCONV_EDGE_RISING;
 sConfigInjected.InjecOversamplingMode = DISABLE;
 if (HAL_ADCEx_InjectedConfigChannel(&hadc2, &sConfigInjected) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfigInjected.InjectedChannel = ADC_CHANNEL_3;
 sConfigInjected.InjectedRank = ADC_INJECTED_RANK_2;
 if (HAL_ADCEx_InjectedConfigChannel(&hadc2, &sConfigInjected) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_COMP1_Init(void)
{
 hcomp1.Instance = COMP1;
 hcomp1.Init.InputPlus = COMP_INPUT_PLUS_IO1;
 hcomp1.Init.InputMinus = COMP_INPUT_MINUS_DAC3_CH1;
 hcomp1.Init.OutputPol = COMP_OUTPUTPOL_NONINVERTED;
 hcomp1.Init.Hysteresis = COMP_HYSTERESIS_NONE;
 hcomp1.Init.BlankingSrce = COMP_BLANKINGSRC_NONE;
 hcomp1.Init.TriggerMode = COMP_TRIGGERMODE_NONE;
 if (HAL_COMP_Init(&hcomp1) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_COMP2_Init(void)
{
 hcomp2.Instance = COMP2;
 hcomp2.Init.InputPlus = COMP_INPUT_PLUS_IO1;
 hcomp2.Init.InputMinus = COMP_INPUT_MINUS_DAC3_CH2;
 hcomp2.Init.OutputPol = COMP_OUTPUTPOL_NONINVERTED;
 hcomp2.Init.Hysteresis = COMP_HYSTERESIS_NONE;
 hcomp2.Init.BlankingSrce = COMP_BLANKINGSRC_NONE;
 hcomp2.Init.TriggerMode = COMP_TRIGGERMODE_NONE;
 if (HAL_COMP_Init(&hcomp2) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_COMP4_Init(void)
{
 hcomp4.Instance = COMP4;
 hcomp4.Init.InputPlus = COMP_INPUT_PLUS_IO1;
 hcomp4.Init.InputMinus = COMP_INPUT_MINUS_DAC3_CH2;
 hcomp4.Init.OutputPol = COMP_OUTPUTPOL_NONINVERTED;
 hcomp4.Init.Hysteresis = COMP_HYSTERESIS_NONE;
 hcomp4.Init.BlankingSrce = COMP_BLANKINGSRC_NONE;
 hcomp4.Init.TriggerMode = COMP_TRIGGERMODE_NONE;
 if (HAL_COMP_Init(&hcomp4) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_CORDIC_Init(void)
{
 hcordic.Instance = CORDIC;
 if (HAL_CORDIC_Init(&hcordic) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_DAC3_Init(void)
{
 
 hdac3.Instance = DAC3;
 if (HAL_DAC_Init(&hdac3) != HAL_OK)
 {
 Error_Handler();
 }
 
 sConfig.DAC_HighFrequency = DAC_HIGH_FREQUENCY_INTERFACE_MODE_AUTOMATIC;
 sConfig.DAC_DMADoubleDataMode = DISABLE;
 sConfig.DAC_SignedFormat = DISABLE;
 sConfig.DAC_SampleAndHold = DAC_SAMPLEANDHOLD_DISABLE;
 sConfig.DAC_Trigger = DAC_TRIGGER_NONE;
 sConfig.DAC_Trigger2 = DAC_TRIGGER_NONE;
 sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE;
 sConfig.DAC_ConnectOnChipPeripheral = DAC_CHIPCONNECT_INTERNAL;
 sConfig.DAC_UserTrimming = DAC_TRIMMING_FACTORY;
 if (HAL_DAC_ConfigChannel(&hdac3, &sConfig, DAC_CHANNEL_1) != HAL_OK)
 {
 Error_Handler();
 }
 
 /** DAC channel OUT2 config
 */
 if (HAL_DAC_ConfigChannel(&hdac3, &sConfig, DAC_CHANNEL_2) != HAL_OK)
 {
 Error_Handler();
 }
}
 
 
static void MX_OPAMP1_Init(void)
{
 hopamp1.Instance = OPAMP1;
 hopamp1.Init.PowerMode = OPAMP_POWERMODE_NORMALSPEED;
 hopamp1.Init.Mode = OPAMP_PGA_MODE;
 hopamp1.Init.NonInvertingInput = OPAMP_NONINVERTINGINPUT_IO0;
 hopamp1.Init.InternalOutput = DISABLE;
 hopamp1.Init.TimerControlledMuxmode = OPAMP_TIMERCONTROLLEDMUXMODE_DISABLE;
 hopamp1.Init.PgaConnect = OPAMP_PGA_CONNECT_INVERTINGINPUT_IO0_BIAS;
 hopamp1.Init.PgaGain = OPAMP_PGA_GAIN_16_OR_MINUS_15;
 hopamp1.Init.UserTrimming = OPAMP_TRIMMING_FACTORY;
 if (HAL_OPAMP_Init(&hopamp1) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_OPAMP2_Init(void)
{
 hopamp2.Instance = OPAMP2;
 hopamp2.Init.PowerMode = OPAMP_POWERMODE_NORMALSPEED;
 hopamp2.Init.Mode = OPAMP_PGA_MODE;
 hopamp2.Init.NonInvertingInput = OPAMP_NONINVERTINGINPUT_IO0;
 hopamp2.Init.InternalOutput = DISABLE;
 hopamp2.Init.TimerControlledMuxmode = OPAMP_TIMERCONTROLLEDMUXMODE_DISABLE;
 hopamp2.Init.PgaConnect = OPAMP_PGA_CONNECT_INVERTINGINPUT_IO0_BIAS;
 hopamp2.Init.PgaGain = OPAMP_PGA_GAIN_16_OR_MINUS_15;
 hopamp2.Init.UserTrimming = OPAMP_TRIMMING_FACTORY;
 if (HAL_OPAMP_Init(&hopamp2) != HAL_OK)
 {
 Error_Handler();
 }
}
 
/**
 * @brief OPAMP3 Initialization Function
 * @PAram None
 * @retval None
 */
static void MX_OPAMP3_Init(void)
{
 hopamp3.Instance = OPAMP3;
 hopamp3.Init.PowerMode = OPAMP_POWERMODE_NORMALSPEED;
 hopamp3.Init.Mode = OPAMP_PGA_MODE;
 hopamp3.Init.NonInvertingInput = OPAMP_NONINVERTINGINPUT_IO0;
 hopamp3.Init.InternalOutput = ENABLE;
 hopamp3.Init.TimerControlledMuxmode = OPAMP_TIMERCONTROLLEDMUXMODE_DISABLE;
 hopamp3.Init.PgaConnect = OPAMP_PGA_CONNECT_INVERTINGINPUT_IO0_BIAS;
 hopamp3.Init.PgaGain = OPAMP_PGA_GAIN_16_OR_MINUS_15;
 hopamp3.Init.UserTrimming = OPAMP_TRIMMING_FACTORY;
 if (HAL_OPAMP_Init(&hopamp3) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_TIM1_Init(void)
{
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 TIMEx_BreakInputConfigTypeDef sBreakInputConfig = {0};
 TIM_OC_InitTypeDef sConfigOC = {0};
 TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
 
 htim1.Instance = TIM1;
 htim1.Init.Prescaler = ((TIM_CLOCK_DIVIDER) - 1);
 htim1.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1;
 htim1.Init.Period = ((PWM_PERIOD_CYCLES) / 2);
 htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV2;
 htim1.Init.RepetitionCounter = (REP_COUNTER);
 htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_OC4REF;
 sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakInputConfig.Source = TIM_BREAKINPUTSOURCE_COMP1;
 sBreakInputConfig.Enable = TIM_BREAKINPUTSOURCE_ENABLE;
 sBreakInputConfig.Polarity = TIM_BREAKINPUTSOURCE_POLARITY_HIGH;
 if (HAL_TIMEx_ConfigBreakInput(&htim1, TIM_BREAKINPUT_BRK, &sBreakInputConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakInputConfig.Source = TIM_BREAKINPUTSOURCE_COMP2;
 if (HAL_TIMEx_ConfigBreakInput(&htim1, TIM_BREAKINPUT_BRK, &sBreakInputConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakInputConfig.Source = TIM_BREAKINPUTSOURCE_COMP4;
 if (HAL_TIMEx_ConfigBreakInput(&htim1, TIM_BREAKINPUT_BRK, &sBreakInputConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_PWM1;
 sConfigOC.Pulse = ((PWM_PERIOD_CYCLES) / 4);
 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();
 }
 if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3) != HAL_OK)
 {
 Error_Handler();
 }
 sConfigOC.OCMode = TIM_OCMODE_PWM2;
 sConfigOC.Pulse = (((PWM_PERIOD_CYCLES) / 2) - (HTMIN));
 if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
 {
 Error_Handler();
 }
 sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_ENABLE;
 sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_ENABLE;
 sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
 sBreakDeadTimeConfig.DeadTime = ((DEAD_TIME_COUNTS) / 2);
 sBreakDeadTimeConfig.BreakState = TIM_BREAK_ENABLE;
 sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
 sBreakDeadTimeConfig.BreakFilter = 4;
 sBreakDeadTimeConfig.BreakAFMode = TIM_BREAK_AFMODE_INPUT;
 sBreakDeadTimeConfig.Break2State = TIM_BREAK2_DISABLE;
 sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;
 sBreakDeadTimeConfig.Break2Filter = 3;
 sBreakDeadTimeConfig.Break2AFMode = TIM_BREAK_AFMODE_INPUT;
 sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
 if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
 {
 Error_Handler();
 }
 HAL_TIM_MspPostInit(&htim1);
 
}
 
static void MX_TIM4_Init(void)
{
 TIM_ClockConfigTypeDef sClockSourceConfig = {0};
 TIM_HallSensor_InitTypeDef sConfig = {0};
 TIM_MasterConfigTypeDef sMasterConfig = {0};
 
 /* USER CODE BEGIN TIM4_Init 1 */
 
 /* USER CODE END TIM4_Init 1 */
 htim4.Instance = TIM4;
 htim4.Init.Prescaler = 0;
 htim4.Init.CounterMode = TIM_COUNTERMODE_UP;
 htim4.Init.Period = M1_HALL_TIM_PERIOD;
 htim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
 htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
 if (HAL_TIM_Base_Init(&htim4) != HAL_OK)
 {
 Error_Handler();
 }
 sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
 if (HAL_TIM_ConfigClockSource(&htim4, &sClockSourceConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sConfig.IC1Polarity = TIM_ICPOLARITY_RISING;
 sConfig.IC1Prescaler = TIM_ICPSC_DIV1;
 sConfig.IC1Filter = M1_HALL_IC_FILTER;
 sConfig.Commutation_Delay = 0;
 if (HAL_TIMEx_HallSensor_Init(&htim4, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 sMasterConfig.MasterOutputTrigger = TIM_TRGO_OC2REF;
 sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
 if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_USART2_UART_Init(void)
{
 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;
 huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
 huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1;
 huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
 if (HAL_UART_Init(&huart2) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_SetTxFifoThreshold(&huart2, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_SetRxFifoThreshold(&huart2, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
 {
 Error_Handler();
 }
 if (HAL_UARTEx_DisableFifoMode(&huart2) != HAL_OK)
 {
 Error_Handler();
 }
}
 
static void MX_DMA_Init(void)
{
 
 /* DMA controller clock enable */
 __HAL_RCC_DMAMUX1_CLK_ENABLE();
 __HAL_RCC_DMA1_CLK_ENABLE();
 
}
 
static void MX_GPIO_Init(void)
{
 GPIO_InitTypeDef GPIO_InitStruct = {0};
 
 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOF_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOB_CLK_ENABLE();
 
 /*Configure GPIO pin : Start_Stop_Pin */
 GPIO_InitStruct.Pin = Start_Stop_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(Start_Stop_GPIO_Port, &GPIO_InitStruct);
}
 
void Error_Handler(void)
{
 /* 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 */
}
#ifdef USE_FULL_ASSERT
 
void assert_failed(uint8_t *file, uint32_t line)
{
 /* USER CODE BEGIN 6 */
 /* User can add his own implementation to report the file name and line number,
 ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
 /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Karl Yamashita

Principal

You didn't read @Andrew Neil post where he has a link

See: How to write your question to maximize your chances to find a solution

It clearly explains on how to insert code so that it is properly formatted and readable. Edit you post and insert the code snippet.

If a reply has proven helpful, click on Accept as Solution so that it'll show at top of the post.CAN Jammer an open source CAN bus hacking toolCANableV3 Open Source

Pavel A.

Super User

Here you can find help with the UART issue and anything else needed for your project.

Karl Yamashita

Principal

Since @EThom.3 inserted part of your code, it's now readable.

The first thing I've noticed is that you have a function inside of main. You should have gotten a warning that the callback is defined but not used during build. Move the callback HAL_UART_RxCpltCallback function outside of main

int main(void)
{
 SystemClock_Config();
 
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_ADC1_Init();
 MX_ADC2_Init();
 MX_COMP1_Init();
 MX_COMP2_Init();
 MX_COMP4_Init();
 MX_CORDIC_Init();
 MX_DAC3_Init();
 MX_OPAMP1_Init();
 MX_OPAMP2_Init();
 MX_OPAMP3_Init();
 MX_TIM1_Init();
 MX_TIM4_Init();
 MX_USART2_UART_Init();
 MX_MotorControl_Init();
 MX_NVIC_Init();
 
 HAL_UART_Receive_IT(&huart2, rx_data, 1);
******************************************************
****** You can't have a function inside of main ******
******************************************************
 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
 {
 
 if (huart->Instance == USART2)
 {
 
 if ((rx_data[0] == 's' || rx_data[0] == 'S') && MC_GetSTMStateMotor1() == IDLE)
 {
 MC_StartMotor1();
 MC_ProgramSpeedRampMotor1(3000, 200);
 }
 else if (rx_data[0] == 'x' || rx_data[0] == 'X')
 {
 MC_StopMotor1();
 }
 
 HAL_UART_Transmit(&huart2, rx_data, 1, 100);
 
 HAL_UART_Receive_IT(&huart2, rx_data, 1);
 }
 
 }
 while (1)
 {
(...)

If a reply has proven helpful, click on Accept as Solution so that it'll show at top of the post.CAN Jammer an open source CAN bus hacking toolCANableV3 Open Source

Pavel A.

Super User

> but still no signs of life from the motor

Then, may be the problem is in the motor? Can you connect it to some other host, for example PC with USB to UART adapter, and send commands?

Sign up

Login with SSO

Login to the community

Login with SSO

Scanning file for viruses.

This file cannot be downloaded