Half Bridge IGBT driving

[Rajat1]

Dear Community,

I am currently working on managing IGBT switching in the frequency range of 20 kHz to 60 kHz. My setup involves directly applying a PWM signal to a pulse transformer, which successfully drives the IGBT. However, I am encountering an issue where the IGBT occasionally burns out at random intervals. After reviewing some documentation, I suspect this is due to hard switching, and I understand that soft switching could improve efficiency and reliability.

From my research, I learned that soft switching may involve applying a short pulse to the IGBT to initiate an LC tank oscillation, then detecting the zero-crossing point (ZCD) to synchronize the next pulse. However, I am uncertain how to implement this in a half-bridge configuration. Specifically:

1. Implementation Method: Should I configure a PWM with complementary outputs, or can I achieve this by manually toggling two GPIOs with a controlled delay?

2. Oscillation Synchronization: How can I effectively read the ZCD signal and synchronize the PWM pulses to match the LC tank’s resonant frequency?

I would greatly appreciate any insights, practical advice, or references to relevant examples or documentation.

[Rajat1]

Post merged (same subject)

Hello everyone,

I am currently working on implementing soft switching for a half-bridge induction heating circuit. After researching various resources, I’ve learned that Zero Current Detection (ZCD) plays a critical role—specifically, detecting the rising edge of the ZCD signal and then starting the PWM after a short delay to achieve soft switching.

However, I am struggling to properly formulate the control logic.

• While I understand that PWM should be initiated after detecting the rising edge of the ZCD, I’m unsure when exactly the PWM should be turned off.

• Additionally, I am unclear on how to coordinate switching of both PWM channels (high and low side) in a synchronized and safe manner.

• I'm also confused about the necessity of reading ZCD a second time if the PWM is already running—should it be used as a trigger for the next switching cycle?

I’ve written a basic program attempting to implement this logic, but unfortunately, it is not functioning as expected. I would deeply appreciate it if anyone could provide guidance, suggest improvements, or share insights into how this can be properly implemented.

I’m attaching my code below for reference. Your suggestions and support would mean a lot.

Thank you in advance!

#include "main.h"
#include "tim.h"
#include "gpio.h"

#define ZCD_DELAY_US 3
#define MIN_FREQ 20000
#define MAX_FREQ 60000
#define TIMER_CLOCK_HZ 84000000

#define FREQ_TO_ARR(freq) (TIMER_CLOCK_HZ / freq)

uint32_t current_arr;

void SystemClock_Config(void);
void Error_Handler(void);

void Start_PWM(uint32_t freq_khz)
{
    uint32_t freq_hz = freq_khz * 1000;
    current_arr = FREQ_TO_ARR(freq_hz);

    TIM1->ARR = current_arr;
    TIM1->CCR1 = current_arr / 2;

    HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
    HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1);
}

void Adjust_Compare_On_ZCD(void)
{
    uint32_t now = __HAL_TIM_GET_COUNTER(&htim1);
    uint32_t delay_ticks = (ZCD_DELAY_US * (TIMER_CLOCK_HZ / 1000000));
    uint32_t next_cmp = (now + delay_ticks) % current_arr;
    __HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, next_cmp);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == GPIO_PIN_0)
    {
        Adjust_Compare_On_ZCD();
    }
}

int main(void)
{
    HAL_Init();
    SystemClock_Config();

    MX_GPIO_Init();
    MX_TIM1_Init();

    Start_PWM(20); // Start at 20 kHz

    while (1)
    {

    }
}

void Error_Handler(void)
{
    while (1) {}
}

[Rajat1]

I would really appreciate if some one could help me to get this problem solve.