The HAL driver and STM32CubeIDE/STM32CubeMX are somewhat restricted in terms of allowing the full use of the One Pulse feature for the TIMx timers.

I noticed a few others (https://www.reddit.com/r/stm32/comments/dn3r9i/need_help_getting_onepulse_to_work_with_the_hal/) and (https://community.st.com/s/question/0D50X00009XkgopSAB/stm32cube-tim-onepulsepwmoc-configuration-issue) who had similar issues to me regarding the One Pulse TIMx features using the HAL and thought I'd write this up quickly to show what I did to get things working with the HAL.

Hopefully it helps someone, took me a few days to figure this all out.

I was trying to have TIM4 trigger TIM2 and couldn't get it working with the HAL. Turns out I had to modify some of the HAL functions since they are basically setup to ONLY work with channels 1 and 2 of a given TIMx.

For instance, HAL_TIM_OnePulse_ConfigChannel() is setup to only work with TI1FP1 or TI2FP2 usage, meaning only when you have the TIM's CH1 trigger CH2 or CH2 trigger CH1.

This can be seen in the code below which is from HAL_TIM_OnePulse_ConfigChannel():

/* Select the Trigger source */
htim->Instance->SMCR &= ~TIM_SMCR_TS;
htim->Instance->SMCR |= TIM_TS_TI1FP1;

/* Select the Slave Mode */
htim->Instance->SMCR &= ~TIM_SMCR_SMS;
htim->Instance->SMCR |= TIM_SLAVEMODE_TRIGGER;

So, if you call the HAL_TIM_SlaveConfigSynchro() function BEFORE you call HAL_TIM_OnePulse_ConfigChannel() then basically the trigger input / slave mode settings would be reset.

Another thing is the HAL_TIM_OnePulse_Start() function which ONLY starts TIMx channels 1 and 2, it will not start channels 3 or 4, and in fact always starts both of them under the assumption that you are using the HAL_TIM_OnePulse_ConfigChannel() function which itself assumes using the TI1FP1 or TI2FP2 triggers.

Without going on and on, this is how I modified the HAL to allow the use of the TIMx channels 1-4 in the One Pulse mode and an example.

I added these function prototypes in stm32h7xx_hal_tim.h:

HAL_StatusTypeDef HAL_TIM_OnePulse_StartChannel(TIM_HandleTypeDef *htim, uint32_t OutputChannel);
HAL_StatusTypeDef HAL_TIM_OnePulse_ConfigChannelOutput(TIM_HandleTypeDef *htim, TIM_OnePulse_InitTypeDef *sConfig, uint32_t OutputChannel);

HAL_TIM_OnePulse_StartChannel() starts each channel (channels 1 to 4) individually instead of HAL_TIM_OnePulse_Start() which only starts channels 1 and 2.

HAL_TIM_OnePulse_ConfigChannelOutput() configures each channel (channels 1 to 4) individually and does not 'reset' the slave mode and trigger settings like HAL_TIM_OnePulse_ConfigChannel() does.

In stm32h7xx_hal.tim.c I added the functions:

HAL_StatusTypeDef HAL_TIM_OnePulse_StartChannel(TIM_HandleTypeDef *htim, uint32_t OutputChannel)
{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(OutputChannel);

  TIM_CCxChannelCmd(htim->Instance, OutputChannel, TIM_CCx_ENABLE);

  if (IS_TIM_BREAK_INSTANCE(htim->Instance) != RESET)
  {
    /* Enable the main output */
    __HAL_TIM_MOE_ENABLE(htim);
  }

  /* Return function status */
  return HAL_OK;
}

HAL_StatusTypeDef HAL_TIM_OnePulse_ConfigChannelOutput(TIM_HandleTypeDef *htim,  TIM_OnePulse_InitTypeDef *sConfig, uint32_t OutputChannel)
{
  TIM_OC_InitTypeDef temp1;

  /* Check the parameters */
  assert_param(IS_TIM_OPM_CHANNELS(OutputChannel));

  /* Process Locked */
  __HAL_LOCK(htim);

  htim->State = HAL_TIM_STATE_BUSY;

  /* Extract the Output compare configuration from sConfig structure */
  temp1.OCMode = sConfig->OCMode;
  temp1.Pulse = sConfig->Pulse;
  temp1.OCPolarity = sConfig->OCPolarity;
  temp1.OCNPolarity = sConfig->OCNPolarity;
  temp1.OCIdleState = sConfig->OCIdleState;
  temp1.OCNIdleState = sConfig->OCNIdleState;

  switch (OutputChannel)
  {
    case TIM_CHANNEL_1:
    {
  	  assert_param(IS_TIM_CC1_INSTANCE(htim->Instance));

	  TIM_OC1_SetConfig(htim->Instance, &temp1);
	  break;
    }
    case TIM_CHANNEL_2:
    {
	  assert_param(IS_TIM_CC2_INSTANCE(htim->Instance));

	  TIM_OC2_SetConfig(htim->Instance, &temp1);
	  break;
    }
    case TIM_CHANNEL_3:
    {
  	  assert_param(IS_TIM_CC3_INSTANCE(htim->Instance));

	  TIM_OC3_SetConfig(htim->Instance, &temp1);
	  break;
    }
    case TIM_CHANNEL_4:
    {
	  assert_param(IS_TIM_CC4_INSTANCE(htim->Instance));

	  TIM_OC4_SetConfig(htim->Instance, &temp1);
	  break;
    }
    default:
	  break;
  }

  htim->State = HAL_TIM_STATE_READY;

  __HAL_UNLOCK(htim);

  return HAL_OK;
}

As an example now, to configure TIM4 in One Pulse mode, triggered by TI2FP2, operating in master/slave mode with it's TRGO set to ENABLE, and having TIM2 in slave mode, triggered by TIM4, corresponding to ITR3, and enabling/starting channels 3 and 4 of TIM2 synchronously, etc:

static void MX_TIM4_Init(void)
{
  TIM_OnePulse_InitTypeDef sConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};
  TIM_MasterConfigTypeDef sMasterConfig = {0};

  htim4.Instance = TIM4;
  htim4.Init.Period            = 0xFFFF;
  htim4.Init.Prescaler         = 0;
  htim4.Init.ClockDivision     = 0;
  htim4.Init.CounterMode       = TIM_COUNTERMODE_UP;
  htim4.Init.RepetitionCounter = 0;

  if (HAL_TIM_OnePulse_Init(&htim4, TIM_OPMODE_SINGLE) != HAL_OK)
  {
    Error_Handler();
  }

  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
  sSlaveConfig.InputTrigger = TIM_TS_TI2FP2;
  sSlaveConfig.TriggerPolarity = TIM_TRIGGERPOLARITY_RISING;
  sSlaveConfig.TriggerFilter = 0;
  
  if (HAL_TIM_SlaveConfigSynchro(&htim4, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }
  
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_ENABLE;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_ENABLE;
  
  if (HAL_TIMEx_MasterConfigSynchronization(&htim4, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

  sConfig.OCMode       = TIM_OCMODE_PWM2;
  sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
  sConfig.Pulse        = 1000;
  sConfig.ICPolarity   = TIM_ICPOLARITY_RISING;
  sConfig.ICSelection  = TIM_ICSELECTION_DIRECTTI;
  sConfig.ICFilter     = 0;
  sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
  sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
  sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;

  if (HAL_TIM_OnePulse_ConfigChannel(&htim4, &sConfig, TIM_CHANNEL_1, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_TIM_OnePulse_StartChannel(&htim4, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_TIM2_Init(void)
{
  TIM_OnePulse_InitTypeDef sConfig = {0};
  TIM_SlaveConfigTypeDef sSlaveConfig = {0};

  htim2.Instance = TIM2;
  htim2.Init.Period            = 0xFFFF;
  htim2.Init.Prescaler         = 0;
  htim2.Init.ClockDivision     = 0;
  htim2.Init.CounterMode       = TIM_COUNTERMODE_UP;
  htim2.Init.RepetitionCounter = 0;

  if (HAL_TIM_OnePulse_Init(&htim2, TIM_OPMODE_SINGLE) != HAL_OK)
  {
    Error_Handler();
  }

  sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;
  sSlaveConfig.InputTrigger = TIM_TS_ITR3;

  if (HAL_TIM_SlaveConfigSynchro(&htim2, &sSlaveConfig) != HAL_OK)
  {
    Error_Handler();
  }

  sConfig.OCMode       = TIM_OCMODE_PWM2;
  sConfig.OCPolarity   = TIM_OCPOLARITY_HIGH;
  sConfig.Pulse        = 1000;
  sConfig.ICPolarity   = TIM_ICPOLARITY_RISING;
  sConfig.ICSelection  = TIM_ICSELECTION_DIRECTTI;
  sConfig.ICFilter     = 0;
  sConfig.OCNPolarity  = TIM_OCNPOLARITY_HIGH;
  sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;
  sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  
  if (HAL_TIM_OnePulse_ConfigChannelOutput(&htim2, &sConfig, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }
  
  sConfig.Pulse        = 2000;
  
  if (HAL_TIM_OnePulse_ConfigChannelOutput(&htim2, &sConfig, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_TIM_OnePulse_StartChannel(&htim2, TIM_CHANNEL_3) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_TIM_OnePulse_StartChannel(&htim2, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
}

EDIT: I actually just used the above to have TIM1 trigger 6 other timers (7 total timers synchronized) as so:

TIM1 (using TI2FP2, PE11 (INPUT)) triggers:
TIM1, CH1, E9 (OUTPUT), using TI2FP2 (TIM1, CH2)
TIM2, CH4, PB11 (OUTPUT), using ITR0 (TIM1)
TIM3, CH3, PB0 (OUTPUT), using ITR0 (TIM1)
TIM4, CH1, PD12 (OUTPUT), using ITR0 (TIM1)
TIM5, CH1, PA0 (OUTPUT), using ITR0 (TIM1)
TIM8, CH2, PC7 (OUTPUT), using ITR0 (TIM1)
TIM15, CH2, PE6 (OUTPUT), using ITR0 (TIM1)

All operating in One Pulse mode.

Here is an image showing the pulses from a Saleae Logic 16: https://imgur.com/a/lsbKAtg (The pulses look the same because I have them all the same for testing purposes, I will soon be implementing CDC USB to allow for configuration of each of the timers through VCP)