Introduction

This application note presents a technique for precharging the DC bus from the AC side, This technique is commonly used in imperix systems.

Proper solutions for discharging the power converter is also addressed.



Context

Nowadays, Voltage Source Converter (VSCs) are widely used in grid-tied applications. They indeed offer several benefits over Current Source Converters (CSCs), such as reduced filtering requirements, superior efficiency and easier use in weak gid conditions.

However, VSCs impose that the DC bus voltage is kept higher than the rectified AC voltage \begin{array}{l}V_r\end{array} at all times. This is indeed essential to avoid uncontrollable current flows through the converter diodes. Besides, this condition is also required by the converter’s own protection mechanism, which assumes that the blocking of all its PWM signals yields rapidly vanishing currents.

As such, VSCs impose to make sure that the DC bus is appropriately pre-charged before normal operation can be initiated. The corresponding condition is \begin{array}{l}V_{DC,min}=\sqrt{3}{V_{peak}}\end{array}.

Failing to guarantee this condition, before or during operation, very high currents may flow into the converter (only limited by parasitic resistances), potentially damaging the power semiconductors.

Pre-charge circuit description

In order to appropriately raise the DC bus voltage before operation, a pre-charge circuit can be introduced between the converter and the grid, made of a three-phase set of resistors. These resistors can be later bypassed during normal operation, thanks to a software-controlled relay. The figure below shows the corresponding circuit.

Example of an application where the DC bus is pre-charged from the AC side.

Principle of operation

Charge

When the converter is not switching and that the DC bus is not charged, all contactors are open. This corresponds to the standby situation.

To charge the DC bus, the first step is to close the contactor K1: then, the converter is connected to the AC grid through resistors, which limit the current flowing from the grid to the DC bus, through the diodes of the inverter. The maximal current flowing into the DC bus capacitor can be expressed as:

\begin{array}{l}\displaystyle I_{max} = \displaystyle\frac{\sqrt{3}V_{peak}}{2 R_{pre}}\end{array}

The second step consists in closing the contactor K2. Then, the converter is closely tied to the grid, and operate normally. The precharge resistors are indeed short-circuited and haven’t any impact on the operation of the converter.

Discharge

For the discharge, all contactors must be opened. Then, a last contactor connected to a load on the DC bus can be closed. The maximum current flowing from the capacitor(s) into the resistance can be expressed as:

\begin{array}{l}\displaystyle I_{max} = V_{dc}/R_{dc}\end{array}

The corresponding discharge time can be expressed as:

\begin{array}{l}\displaystyle t_{dis} = 3\cdot\tau=3\cdot R_{dc}\cdot C_{dc}\end{array}

Another option consists in re-activating the converter after all contactors are open in order to generate sufficient switching losses so that the discharge of the DC bus is accelerated.

State machine implementation

As already explained, the order of opening/closing contactors is absolutely essential as to avoid potentially damaging current flows. It is also important to take into account the time that each contactor requires for its operation.

For this purpose, the implementation of a state machine is recommended. This also facilitates the grid connection/disconnection procedures, thanks to automated mechanisms. The following shows the implementation of a state machine in C++, Simulink, and PLECS. The grid-tied inverter of the AN006 uses that state machine to automate the pre-charge and grid connection processes.

Implementation of a state machine in C++.
// The system can freely change between each states
switch (State){
  case STANDBY:
    // All the relays must be opened:
    Gpo_ClearBit(Relay_gP);
    Gpo_ClearBit(Relay_gB);
    Gpo_ClearBit(Relay_b);
    Gpo_ClearBit(Relay_D);
    // All PWM channels must be deactivated:
    CbPwm_Deactivate(PWM_CHANNEL_0);
    CbPwm_Deactivate(PWM_CHANNEL_1);
    CbPwm_Deactivate(PWM_CHANNEL_2);
    CbPwm_Deactivate(PWM_CHANNEL_3);
    
    if(State_desired == 1 && core_state>0){
      State_next = CHARGING;
    }
    break;

  case CHARGING:
    // Close the grid Precharge relay:
    Gpo_SetBit(Relay_gP);
    
    if(abs(Iga)<1 && abs(Igb)<1 && abs(Igc)<1 && Vdc>Vdc_min){
      State_next = CHARGED
    }
    else if(core_state==0){
      State_next = DISCONNECTING;
    }
    break;

  case CHARGED:
    // Close the grid Bypass relay and the battery relay:
    Gpo_SetBit(Relay_gB);
    Gpo_SetBit(Relay_b);
    
    if(core_state==0){
      State_next = DISCONNECTING;
    }
    break;

  case READY:
    // Activate the power modules:
    CbPwm_Activate(PWM_CHANNEL_0);
    CbPwm_Activate(PWM_CHANNEL_1);
    CbPwm_Activate(PWM_CHANNEL_2);
    CbPwm_Activate(PWM_CHANNEL_3);
    
    if(State_desired == 0 || core_state==0){
      State_next = DISCONNECTING;
    }
    break;

  case DISCONNECTING:
    // open all the relay and deactivate the power modules:
    Gpo_ClearBit(Relay_gP);
    Gpo_ClearBit(Relay_gB);
    Gpo_ClearBit(Relay_b);
    CbPwm_Deactivate(PWM_CHANNEL_0);
    CbPwm_Deactivate(PWM_CHANNEL_1);
    CbPwm_Deactivate(PWM_CHANNEL_2);
    CbPwm_Deactivate(PWM_CHANNEL_3);
    
    State_next = WAITING;
    cnt = 0;
    break;
    
  case WAITING:
    if(cnt>fs/2){
      State_next = DISCHARGING;
    }
    cnt++;
    break;

  case DISCHARGING:
    // Close the discharge relay:
    Gpo_SetBit(Relay_D);
    
    if(Vdc<10){
      State_next = STANDBY;
    }
    break;
}
State = State_next;

Implementation of a state machine in Simulink, using the toolbox Stateflow.

Implementation of a state machine in PLECS
  • No labels