Is it possible to have a center (or centre in old english) aligned PWM timer wth a secondary channel that has a delay(phase shifted)? I have seen it done with the standard count up timer but I am struggling to achieve this in center aligned mode.

[JGrah]

I am using STM32L4R5ZI. I have setup TIM1 as a slave of TIM2 and have set both to centeraligned mode 3. I am driving the PWM to a frequency of 21kHz. I can get the correct duty cycle and frequency on TIM2 CH1 / CH2 but am struggling to get the correct duty cycle and offset on TIM1 CH1.

/* Includes ------------------------------------------------------------------*/

#include "tim.h"

/* USER CODE BEGIN 0 */

uint32_t clock_frequency = 120000000;

// Desired pump frequency in hertz

uint32_t pump_frequency = 21000;

/* USER CODE END 0 */

TIM_HandleTypeDef htim1;

TIM_HandleTypeDef htim2;

/* TIM1 init function */

void MX_TIM1_Init(void)

{

uint16_t counterPeriod = clock_frequency / pump_frequency;

TIM_ClockConfigTypeDef sClockSourceConfig =

{ 0 };

TIM_SlaveConfigTypeDef sSlaveConfig =

{ 0 };

TIM_MasterConfigTypeDef sMasterConfig =

{ 0 };

TIM_OC_InitTypeDef sConfigOC =

{ 0 };

TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig =

{ 0 };

htim1.Instance = TIM1;

htim1.Init.Prescaler = 0;

htim1.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED3;

htim1.Init.Period = (counterPeriod /8);

htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

htim1.Init.RepetitionCounter = 0;

htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;

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();

}

if (HAL_TIM_OnePulse_Init(&htim1, TIM_OPMODE_SINGLE) != HAL_OK)

{

Error_Handler();

}

sSlaveConfig.SlaveMode = TIM_SLAVEMODE_TRIGGER;

sSlaveConfig.InputTrigger = TIM_TS_ITR1;

if (HAL_TIM_SlaveConfigSynchronization(&htim1, &sSlaveConfig) != HAL_OK)

{

Error_Handler();

}

sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;

sMasterConfig.MasterOutputTrigger2 = TIM_TRGO2_RESET;

sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)

{

Error_Handler();

}

sConfigOC.OCMode = TIM_OCMODE_PWM1;

sConfigOC.Pulse = 1;

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();

}

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.Break2State = TIM_BREAK2_DISABLE;

sBreakDeadTimeConfig.Break2Polarity = TIM_BREAK2POLARITY_HIGH;

sBreakDeadTimeConfig.Break2Filter = 0;

sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;

if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)

{

Error_Handler();

}

HAL_TIM_MspPostInit(&htim1);

}

/* TIM2 init function */

void MX_TIM2_Init(void)

{

uint16_t counterPeriod = clock_frequency / pump_frequency;

TIM_ClockConfigTypeDef sClockSourceConfig =

{ 0 };

TIM_MasterConfigTypeDef sMasterConfig =

{ 0 };

TIM_OC_InitTypeDef sConfigOC =

{ 0 };

htim2.Instance = TIM2;

htim2.Init.Prescaler = 0;

htim2.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED3;

htim2.Init.Period = counterPeriod / 2;

htim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;

htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;

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_OC1;

sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;

if (HAL_TIMEx_MasterConfigSynchronization(&htim2, &sMasterConfig) != HAL_OK)

{

Error_Handler();

}

sConfigOC.OCMode = TIM_OCMODE_PWM1;

sConfigOC.Pulse = counterPeriod / 8;

sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;

sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;

if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)

{

Error_Handler();

}

sConfigOC.OCMode = TIM_OCMODE_PWM1;

sConfigOC.Pulse = counterPeriod / 8;

if (HAL_TIM_PWM_ConfigChannel(&htim2, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)

{

Error_Handler();

}

HAL_TIM_MspPostInit(&htim2);

}