drv_pwrctrl_app_TPBLPFC.c

Go to the documentation of this file.

 
/*
� [2024] Microchip Technology Inc. and its subsidiaries.
 
    Subject to your compliance with these terms, you may use Microchip 
    software and any derivatives exclusively with Microchip products. 
    You are responsible for complying with 3rd party license terms  
    applicable to your use of 3rd party software (including open source  
    software) that may accompany Microchip software. SOFTWARE IS ?AS IS.? 
    NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS 
    SOFTWARE, INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT,  
    MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 
    WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, 
    INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY 
    KIND WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF 
    MICROCHIP HAS BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE 
    FORESEEABLE. TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP?S 
    TOTAL LIABILITY ON ALL CLAIMS RELATED TO THE SOFTWARE WILL NOT 
    EXCEED AMOUNT OF FEES, IF ANY, YOU PAID DIRECTLY TO MICROCHIP FOR 
    THIS SOFTWARE.
 */
 
 
#include <p33CH512MP506S1.h>
 
#include "../../../mcc_generated_files/system/pins.h"
#include "../../../mcc_generated_files/cmp/cmp1.h"
//#include "../../../mcc_generated_files/pwm_hs/pwm.h"
#include "drv_controller_TPBLPFC.h"
#include "../../devices/dev_TPBLPFC_typedef.h"
#include "PFC_frameworkSetup.h"
#include "../../misc/MCC_add_on.h"
#include "drv_pwrctrl_app_TPBLPFC.h"
 
 
static void VOUTaveraging(void);
static void VOUT_HystereticCheck(void);
static void ZeroCross_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void SoftstartAfterZC_PHx_GTIMode(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void SoftstartAfterZC_PHx_PFCMode(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void CCM_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void DutyCycleFeedForward_PHx(struct PHASE_VALUES_s* PhaseX);
static void BurstMode_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void Handler_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr);
static void Adaptive_Currentcontroller_Gain(uint16_t PWMnr);
 
 
void Application_handler_PH1(void)
{
 
  _LATC12 = Phase_Values_PH1.ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range;
  //    _LATC12 = Phase_Values_PH1.Control_Status_Flags.bits.Soft_Start_Zero_Cross;
  DAC1DATH = (Phase_Values_PH1.Controller_Values.IAC_Reference >> 1);
 
  VOUTaveraging();
 
  //Vout limits and dV/dt check
#ifdef ADAPTIVE_STEPRESPONSE_ENABLED
  if ((pwr_ctrl_state == PCS_UP_AND_RUNNING))
  {
    VOUT_HystereticCheck();
  }
#endif
  //PHASE #1  
  Handler_PHx(&Phase_Values_PH1, 1);
 
}
 
void Application_handler_PH2(void)
{
 
#if defined MODE_INTERLEAVED
  //PHASE #2  
  Handler_PHx(&Phase_Values_PH2, 2);
#endif
 
}
 
 
static void __inline__ Handler_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
 
  if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_OK)
  {
    //<ZC range detection and handling, polarity change check
    ZeroCross_PHx(PhaseX, PWMnr);
 
#ifdef VOUT_PRECHARGE_PCS_ENABLE
    if (pwr_ctrl_state > PCS_VACOK)
#else
    if (PhaseX->Control_Status_Flags.bits.Relay)
#endif
    {
#ifdef AC_CYCLE_SKIPPING_ENABLED 
      // Burst mode checked after startup ramp or if ref changed during run mode
      if ((pwr_ctrl_state == PCS_UP_AND_RUNNING) || PhaseX->Control_Status_Flags.bits.Reference_Changed)
      {
        BurstMode_PHx(PhaseX, PWMnr);
      }
#endif
#ifdef MODE_GRID_TIE_INVERTER
      SoftstartAfterZC_PHx_GTIMode(PhaseX, PWMnr); //GTI special switch handling 
#else
      //#if defined MODE_PFC || defined MODE_INTERLEAVED
      SoftstartAfterZC_PHx_PFCMode(PhaseX, PWMnr); //PFC mode standard switch handling
#endif
      //synch switch handling based on polarity 
      if ((!PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross) &&
        (!PhaseX->ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range) &&
        ((pwr_ctrl_state == PCS_UP_AND_RUNNING) || PhaseX->Control_Status_Flags.bits.Reference_Changed))
      {
#ifdef VOLTAGE_LOOP
        if (Vout_Control.Reference.Voltage_Loop_Output > BURST_MODE_VMC_REF_FREEZE)
#endif
          CCM_PHx(PhaseX, PWMnr);
      }
    }
 
#ifdef VOLTAGE_LOOP
    if ((Vout_Control.Vout.FilterCounter < 1) && (PWMnr == 1))
    {
      //outer voltage loop
      if (PhaseX->Controller_Values.Control_Freeze)
      {
        Vout_Control.Reference.Voltage_Loop_Output = BURST_MODE_VMC_REF_FREEZE;
      }
      else
      {
        SMPS_Controller2P2ZUpdate(&VMC_2p2z, &Vout_Control.Vout.Filtered, Vout_Control.Reference.Reference_Internal,
          &Vout_Control.Reference.Voltage_Loop_Output);
      }
    }
#endif
 
    //Current loop
    if (!PhaseX->ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range)
    {
#ifdef VOLTAGE_LOOP
      PhaseX->Controller_Values.IAC_Reference_l = (__builtin_mulss((Vout_Control.Reference.Voltage_Loop_Output), (PhaseX->Phase_Voltage.Vin_div_Averaged2)));
#else
      PhaseX->Controller_Values.IAC_Reference_l = (__builtin_mulss((Vout_Control.Reference.Reference_Internal << 3), PhaseX->Phase_Voltage.Vin_div_Averaged2));
#endif
 
      PhaseX->Controller_Values.IAC_Reference = (PhaseX->Controller_Values.IAC_Reference_l >> 15); //shift only 15 because of 2 signed bits in mulss
 
#ifndef VOLTAGE_LOOP
      if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VDC_Input_Voltage)
      {
        PhaseX->Controller_Values.IAC_Reference = (Vout_Control.Reference.Reference_Internal); //IAC reference is 31 digits per Ampere left shifted by 4
      }
#endif     
 
      PhaseX->Phase_Current.Rectified_Shift = (uint16_t) (PhaseX->Phase_Current.Rectified << 4); //<<< 4
      //inner current loop
      if (!PhaseX->Controller_Values.Control_Freeze) //Freezed because of cycle skipping
      {
        Adaptive_Currentcontroller_Gain(PWMnr);
        PHx_AVG_CM2p2z[PWMnr].KfactorCoeffsB = Adaptive_Gain_Factor;
 
#ifdef MODE_INTERLEAVED
#endif
 
        XFT_SMPS_Controller2P2ZUpdate(&PHx_AVG_CM2p2z[PWMnr], &PhaseX->Phase_Current.Rectified_Shift, PhaseX->Controller_Values.IAC_Reference,
          &(PhaseX->Controller_Values.Duty_Cycle_Set_Value));
      }
 
#ifdef DUTY_RATIO_FEEDFORWARD_ENABLED     
      //DC ff / switch handling when NOT in light load
      if ((!PhaseX->Control_Status_Flags.bits.BurstModeLatched))
      {
        DutyCycleFeedForward_PHx(PhaseX);
      }
#endif
 
      //Vout precharge option with openloop fixed duty cycle 50% at LV and 25% at HV
      if (pwr_ctrl_state == PCS_VOUT_PRELOAD)
      {
#if HIGH_VOLTAGE        
#ifdef MODE_INTERLEAVED
        PhaseX->Controller_Values.Duty_Cycle_Set_Value = MPER >> 2;
#else
        PhaseX->Controller_Values.Duty_Cycle_Set_Value = MPER >> 2; //open loop precharge with fix 25% duty cycle
#endif
#else
        PhaseX->Controller_Values.Duty_Cycle_Set_Value = MPER >> 1;
#endif
      }
 
      //check min/max value
      if (PhaseX->Controller_Values.Duty_Cycle_Set_Value < DCMIN) PhaseX->Controller_Values.Duty_Cycle_Set_Value = 0;
      if (PhaseX->Controller_Values.Duty_Cycle_Set_Value > DCMAX) PhaseX->Controller_Values.Duty_Cycle_Set_Value = DCMAX;
 
 
      //      PWM_TriggerCompareValueSet(PWMnr,PhaseX->Controller_Values.Duty_Cycle_Set_Value >> 1);
      if (PWMnr == 1) PG1TRIGA = (Phase_Values_PH1.Controller_Values.Duty_Cycle_Set_Value >> 1);
      if (PWMnr == 2) PG2TRIGA = (Phase_Values_PH2.Controller_Values.Duty_Cycle_Set_Value >> 1);
 
      //update duty cycle with controller output value only when out of zero cross startup
      //zero cross startup is in open loop in function SoftstartAfterZC_PHx_XXX
      if (!PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross)
      {
        PWM_DutyCycleSet(PWMnr, PhaseX->Controller_Values.Duty_Cycle_Set_Value);
      }
    }
 
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_last = PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity;
  }
}
 
 
static void __inline__ VOUTaveraging(void)
{
 
  static uint32_t VoutAVGsum, PH1AVGCurrentsum, PH2AVGCurrentsum;
  static uint32_t PH1AVGCurrentOffset, PH2AVGCurrentOffset;
  static uint16_t vac_pol_changed_counter;
  static uint16_t PH1vac_pol_changed_counter, PH2vac_pol_changed_counter;
 
  Vout_Control.Vout.FilterCounter++;
  Phase_Values_PH1.Phase_Current.FilterCounter++;
  Phase_Values_PH2.Phase_Current.FilterCounter++;
 
  VoutAVGsum += Vout_Control.Vout.Raw;
 
  //averaging of input current
  PH1AVGCurrentsum += Phase_Values_PH1.Phase_Current.Rectified; //time consuming instruction, optimize with asm
  //  PH2AVGCurrentsum += Phase_Values_PH2.Phase_Current.Rectified;
 
  if ((Phase_Values_PH1.Control_Status_Flags.bits.VAC_Polarity_Changed)
    && (!Phase_Values_PH1.Control_Status_Flags.bits.VAC_Polarity_Changed_last))
  {
    vac_pol_changed_counter++;
    PH1vac_pol_changed_counter++;
    PH2vac_pol_changed_counter++;
  }
 
  if (((vac_pol_changed_counter > 0) && (Vout_Control.Vout.FilterCounter > 1))
    || (Vout_Control.Vout.FilterCounter > 8000))
  {
    Vout_Control.Vout.PreviousValue = Vout_Control.Vout.Filtered;
    Vout_Control.Vout.Filtered = (uint16_t) (__builtin_divud(VoutAVGsum, Vout_Control.Vout.FilterCounter - 1));
    VoutAVGsum = 0;
    vac_pol_changed_counter = 0;
    Vout_Control.Vout.FilterCounter = 0;
  }
 
  // after power up during initialization the current sensor calibration is done
  if (pwr_ctrl_state == PCS_INIT)
  {
    PH1AVGCurrentOffset += Phase_Values_PH1.Phase_Current.Raw;
    PH2AVGCurrentOffset += Phase_Values_PH2.Phase_Current.Raw;
 
    if (((PH1vac_pol_changed_counter > 1) && (Phase_Values_PH1.Phase_Current.FilterCounter > 1))
      || (Phase_Values_PH1.Phase_Current.FilterCounter > 4000)) //4000=40ms/10us
    {
      Phase_Values_PH1.Phase_Current.Offset = (uint16_t) (__builtin_divud(PH1AVGCurrentOffset, Phase_Values_PH1.Phase_Current.FilterCounter - 1));
      PH1AVGCurrentsum = 0;
      PH1AVGCurrentOffset = 0;
      PH1vac_pol_changed_counter = 0;
      Phase_Values_PH1.Phase_Current.FilterCounter = 0;
    }
    if (((PH2vac_pol_changed_counter > 1) && (Phase_Values_PH2.Phase_Current.FilterCounter > 1))
      || (Phase_Values_PH2.Phase_Current.FilterCounter > 4000)) //4000=40ms/10us
    {
      Phase_Values_PH2.Phase_Current.Offset = (uint16_t) (__builtin_divud(PH2AVGCurrentOffset, Phase_Values_PH2.Phase_Current.FilterCounter - 1));
      PH2AVGCurrentsum = 0;
      PH2AVGCurrentOffset = 0;
      PH2vac_pol_changed_counter = 0;
      Phase_Values_PH2.Phase_Current.FilterCounter = 0;
    }
  }
 
  //averaging of input current  
  if (pwr_ctrl_state == PCS_UP_AND_RUNNING)
  {
    if (((PH1vac_pol_changed_counter > 1) && (Phase_Values_PH1.Phase_Current.FilterCounter > 1)) || (Phase_Values_PH1.Phase_Current.FilterCounter > 4000)) //4000=40ms/10us
    {
      Phase_Values_PH1.Phase_Current.Filtered = (uint16_t) (__builtin_divud(PH1AVGCurrentsum, Phase_Values_PH1.Phase_Current.FilterCounter - 1));
      PH1AVGCurrentsum = 0;
      PH1AVGCurrentOffset = 0;
      PH1vac_pol_changed_counter = 0;
      Phase_Values_PH1.Phase_Current.FilterCounter = 0;
    }
 
    //    if (((PH2vac_pol_changed_counter > 1) && (Phase_Values_PH2.Phase_Current.FilterCounter > 1)) || (Phase_Values_PH2.Phase_Current.FilterCounter > 4000)) //4000=40ms/10us
    //    {
    //      Phase_Values_PH2.Phase_Current.Filtered = (uint16_t) (__builtin_divud(PH2AVGCurrentsum, Phase_Values_PH2.Phase_Current.FilterCounter - 1));
    //      PH2AVGCurrentsum = 0;
    //      PH2AVGCurrentOffset = 0;
    //      PH2vac_pol_changed_counter = 0;
    //      Phase_Values_PH2.Phase_Current.FilterCounter = 0;
    //    }
  }
 
  Phase_Values_PH1.Control_Status_Flags.bits.VAC_Polarity_Changed_last = Phase_Values_PH1.Control_Status_Flags.bits.VAC_Polarity_Changed;
 
}
 
 
static void __inline__ ZeroCross_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
 
  //switch off main and synch switches at ZC area ---------------------------
  if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range)
  {
    PWM_OverrideHighEnable(PWMnr);
    PWM_OverrideLowEnable(PWMnr);
    PWM_H_N_SetLow();
    PWM_L_N_SetLow();
 
    //reset duty cycle to 0 to startup later from low duty cycle values
    PWM_DutyCycleSet(PWMnr, 0);
 
    PhaseX->Controller_Values.CCM_Counter = 1;
    //CCM_Counter used as hysteresis around the CCM_CURRENT value 
    //in MODE_GRID_TIE_INVERTER the CCM counter can be greater as 
    //CCM level at end of half wave and synch is enabled
    //at the begin of the next half wave after ZC range synch switch is enabled
    //because of DCM counter needs to be count down after ZC range
  }
 
  //polarity change check ---------------------------------------------------
  if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity != PhaseX->Control_Status_Flags.bits.VAC_Polarity_last)
  {
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed = 1;
 
    PhaseX->Controller_Values.BurstModeCycleCounter++; //Burst Mode cycle count
  }
 
}
 
 
static void __inline__ SoftstartAfterZC_PHx_GTIMode(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
  uint16_t pg1dc_;
 
  //switch on main switches after polarity change and ZC range is over and before ZC startup 
  if (PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed &&
    (!PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross) &&
    (!PhaseX->ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range))
  {
    PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross = 1;
    PhaseX->Controller_Values.PWM_Counter = 0;
 
    if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
    {
      //startup after ZC like PFC
      PWM_SwapEnable(PWMnr);
      PWM_OverrideLowDisable(PWMnr);
      PWM_OverrideHighEnable(PWMnr);
    }
    else
    {
      //startup after ZC like PFC
      PWM_SwapDisable(PWMnr);
      PWM_OverrideHighDisable(PWMnr);
      PWM_OverrideLowEnable(PWMnr);
    }
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed = 0;
  }
 
  //open loop startup after ZC
  if (PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross)
  {
    // openloop startup after ZC
    // number of PWM periods: 
    if (++PhaseX->Controller_Values.PWM_Counter < OPEN_LOOP_STARTUP_PULSES)
    {
      pg1dc_ = (PhaseX->Controller_Values.PWM_Counter << OPEN_LOOP_PWM_COUNTER_SHIFT);
      //      GPIO_Y_L_Toggle();
      PWM_DutyCycleSet(PWMnr, pg1dc_);
    }
    else
    {
      PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross = 0;
 
      PhaseX->Controller_Values.PWM_Counter = 30;
 
      // LF switch starts up after a few cycles
      if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
      {
        PWM_SwapDisable(PWMnr);
        PWM_OverrideHighDisable(PWMnr);
        PWM_OverrideLowEnable(PWMnr);
 
        if (pwr_ctrl_state > PCS_START_CONTROL)
        {
          PWM_H_N_SetLow();
          PWM_L_N_SetHigh();
        }
      }
      else
      {
        PWM_SwapEnable(PWMnr);
        PWM_OverrideLowDisable(PWMnr);
        PWM_OverrideHighEnable(PWMnr);
 
        if (pwr_ctrl_state > PCS_START_CONTROL)
        {
          PWM_L_N_SetLow();
          PWM_H_N_SetHigh();
        }
      }
    }
  }
 
}
 
 
static void __inline__ SoftstartAfterZC_PHx_PFCMode(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
  uint16_t pg1dc_;
 
  //switch on main switches after polarity change and ZC range is over and before ZC startup 
  if (PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed &&
    (!PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross) &&
    (!PhaseX->ACcontrol_Status_Flags_perPhase.bits.Zero_Cross_Range))
  {
    PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross = 1;
    PhaseX->Controller_Values.PWM_Counter = 0;
 
    if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
    {
      //switch handling when NOT in light load
      if ((!PhaseX->Control_Status_Flags.bits.BurstModeLatched) && (!Vout_Control.Reference.VOUT_dV_dt_Active))
      {
        PWM_SwapEnable(PWMnr);
        PWM_OverrideLowDisable(PWMnr);
        PWM_OverrideHighEnable(PWMnr);
      }
    }
    else
    {
      //switch handling when NOT in light load
      if ((!PhaseX->Control_Status_Flags.bits.BurstModeLatched) && (!Vout_Control.Reference.VOUT_dV_dt_Active))
      {
        PWM_SwapDisable(PWMnr);
        PWM_OverrideHighDisable(PWMnr);
        PWM_OverrideLowEnable(PWMnr);
      }
    }
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed = 0;
  }
 
  //LF switch start after x-cycles in OL like PFC mode 
  if (PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross)
  {
#ifdef COMMON_MODE_DETECTION
    if (((!PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity) &&
      (AC_N.Phase_Voltage.Raw < (Vout_Control.Vout.Filtered - (Vout_Control.Vout.Filtered >> 2)))) ||
      ((PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity) &&
      (AC_N.Phase_Voltage.Raw > 500 /*200mV*/))
      )
#else
    // openloop startup after ZC  
    //    if (++PhaseX->Controller_Values.PWM_Counter < OPEN_LOOP_STARTUP_PULSES)
    if (++PhaseX->Controller_Values.PWM_Counter < OpenLoopStartupDuration)
#endif      
    {
 
#ifdef COMMON_MODE_DETECTION
      ++PhaseX->Controller_Values.PWM_Counter; //only for AC_N needed to get OL pulses
#endif
 
#ifdef CHARGEPUMP_ENABLED 
      // charge pump I/O handling: 100us on
      // if no charge pump hardware I/O pins are set without acting
      if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
        GPIO_Y_L_SetHigh();
      else
        GPIO_Y_H_SetHigh();
#else     
      pg1dc_ = (PhaseX->Controller_Values.PWM_Counter << OPEN_LOOP_PWM_COUNTER_SHIFT);
      //      GPIO_Y_L_Toggle();
      PWM_DutyCycleSet(PWMnr, pg1dc_);
#endif
    }
    else
    {
      PhaseX->Control_Status_Flags.bits.Soft_Start_Zero_Cross = 0;
 
      PhaseX->Controller_Values.PWM_Counter = 30;
 
#if defined CHARGEPUMP_ENABLED  
      // charge pump I/O handling
      GPIO_Y_H_SetLow();
      GPIO_Y_L_SetLow();
 
      //switch handling when NOT in light load
      if ((!PhaseX->Control_Status_Flags.bits.BurstModeLatched) && (!Vout_Control.Reference.VOUT_dV_dt_Active))
      {
        if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
        {
          PWM_SwapEnable(PWMnr);
          PWM_OverrideLowDisable(PWMnr);
          PWM_OverrideHighEnable(PWMnr);
        }
        else
        {
          PWM_SwapDisable(PWMnr);
          PWM_OverrideHighDisable(PWMnr);
          PWM_OverrideLowEnable(PWMnr);
        }
      }
#endif
 
      // LF switches are on after open loop startup,
#if defined RECTIFIER_SWITCH 
      // LF switch starts up after a few cycles
      if (!PhaseX->Controller_Values.Control_Freeze)
      {
        if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
        {
          if (pwr_ctrl_state > PCS_START_CONTROL)
          {
            PWM_H_N_SetLow();
            PWM_L_N_SetHigh();
          }
        }
        else
        {
          if (pwr_ctrl_state > PCS_START_CONTROL)
          {
            PWM_L_N_SetLow();
            PWM_H_N_SetHigh();
          }
        }
      }
#endif   
    }
  }
 
}
 
 
static void __inline__ CCM_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
  uint16_t var1_ui, var2_ui;
 
  // current fix for DCM;
  var1_ui = PhaseX->Phase_Current.Rectified;
  var2_ui = CCM_CURRENT;
 
  if (var1_ui > var2_ui)
  {
    PhaseX->Controller_Values.CCM_Counter++;
  }
  else if (var1_ui < var2_ui)
  {
    PhaseX->Controller_Values.CCM_Counter--;
  }
 
  if (PhaseX->Controller_Values.CCM_Counter > 6)
  {
    PhaseX->Controller_Values.CCM_Counter = 6;
    PhaseX->Control_Status_Flags.bits.CCM = 1;
  }
  if (PhaseX->Controller_Values.CCM_Counter < 1)
  {
    PhaseX->Controller_Values.CCM_Counter = 1;
    PhaseX->Control_Status_Flags.bits.CCM = 0;
  }
 
#ifdef SYNCHRONOUS_ACTIVE_SWITCH
  if (PhaseX->Control_Status_Flags.bits.CCM)
  {
    if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
    {
#ifndef MODE_GRID_TIE_INVERTER       
      PWM_OverrideHighDisable(PWMnr); //PWM ON
#else
      PWM_OverrideLowDisable(PWMnr); //PWM ON
#endif        
    }
    else
    {
#ifndef MODE_GRID_TIE_INVERTER     
      PWM_OverrideLowDisable(PWMnr); //PWM ON
#else
      PWM_OverrideHighDisable(PWMnr); //PWM ON
#endif        
    }
  }
  else
  {
    if (PhaseX->ACcontrol_Status_Flags_perPhase.bits.VAC_Polarity)
    {
#ifndef MODE_GRID_TIE_INVERTER     
      PWM_OverrideHighEnable(PWMnr); //PWM OFF
#else
      PWM_OverrideLowEnable(PWMnr); //PWM OFF
#endif        
    }
    else
    {
#ifndef MODE_GRID_TIE_INVERTER     
      PWM_OverrideLowEnable(PWMnr); //PWM OFF
#else
      PWM_OverrideHighEnable(PWMnr); //PWM OFF
#endif        
    }
  }
#endif 
 
}
 
 
static void __inline__ DutyCycleFeedForward_PHx(struct PHASE_VALUES_s * PhaseX)
{
  uint32_t var_ul;
  uint16_t var1_ui;
 
  if (Vout_Control.Vout.Filtered > PhaseX->Phase_Voltage.Rectified)
  {
    var1_ui = Vout_Control.Vout.Filtered - PhaseX->Phase_Voltage.Rectified; //Vout - Vin
    var_ul = (uint32_t) var1_ui * MPER;
    var1_ui = __builtin_divud(var_ul, Vout_Control.Vout.Filtered);
    PhaseX->Controller_Values.Duty_Cycle_Set_Value = PhaseX->Controller_Values.Duty_Cycle_Set_Value + (var1_ui >> 2);
  }
 
}
 
 
static void __inline__ BurstMode_PHx(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
{
 
  if ((Vout_Control.Reference.Voltage_Loop_Output < BURST_MODE_LEVEL_HIGH) &&
    !PhaseX->Control_Status_Flags.bits.BurstModeLatched)
  {
    PhaseX->Control_Status_Flags.bits.BurstModeDetected = 1;
  }
 
  if (PhaseX->Control_Status_Flags.bits.BurstModeDetected &&
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_Changed &&
    PhaseX->Control_Status_Flags.bits.VAC_Polarity_last)
  {
    PhaseX->Control_Status_Flags.bits.BurstModeLatched = 1;
    PhaseX->Control_Status_Flags.bits.BurstModeDetected = 0;
    PhaseX->Controller_Values.Control_Freeze = 1;
    PhaseX->Controller_Values.BurstModeCycleCounter = 0;
    PhaseX->Controller_Values.BurstModeCyclesOn = 0;
 
    PWM_OverrideHighEnable(PWMnr);
    PWM_OverrideLowEnable(PWMnr);
    PWM_H_N_SetLow();
    PWM_L_N_SetLow();
  }
 
  if ((PhaseX->Controller_Values.BurstModeCycleCounter > 1))
  {
    PhaseX->Control_Status_Flags.bits.BurstModeLatched = 0;
    PhaseX->Controller_Values.Control_Freeze = 0;
    PhaseX->Controller_Values.BurstModeCycleCounter = 0;
  }
 
}
 
 
static void __inline__ VOUT_HystereticCheck(void)
{
 
  if ((Vout_Control.Vout.Filtered > Vout_Control.Reference.VOUT_dV_dt_Hystresis_High))
    //  if ((Vout_Control.Vout.Raw > Vout_Control.Reference.VOUT_dV_dt_Hystresis_High))
  {
    Vout_Control.Reference.VOUT_dV_dt_Active = 1;
    Vout_Control.Reference.VOUT_dV_dt_Up = 1;
    PWM_OverrideHighEnable(1);
    PWM_OverrideLowEnable(1);
    PWM_OverrideHighEnable(2);
    PWM_OverrideLowEnable(2);
    PWM_OverrideHighEnable(3);
    PWM_OverrideLowEnable(3);
    PWM_H_N_SetLow();
    PWM_L_N_SetLow();
  }
 
  if ((Vout_Control.Vout.Raw < Vout_Control.Reference.VOUT_Hystresis_High) &&
    (Vout_Control.Vout.Raw > Vout_Control.Reference.VOUT_Hystresis_Low))
  {
    Vout_Control.Reference.VOUT_dV_dt_Active = 0;
    Vout_Control.Reference.VOUT_dV_dt_Up = 0;
  }
 
}
 
 
//static void __inline__ Adaptive_Currentcontroller_Gain(struct PHASE_VALUES_s* PhaseX, uint16_t PWMnr)
 
static void __inline__ Adaptive_Currentcontroller_Gain(uint16_t PWMnr)
{
  uint32_t mul01;
  uint16_t mul02;
 
#ifndef ADAPTIVE_GAIN_ENABLED
  PFC_Flags.bits.AGOn = 0;
#endif
 
#ifdef ADAPTIVE_GAIN_SLIDER_MODE
  Adaptive_Gain_Factor = Adaptive_Gain_Factor;
#else
 
#if defined (MODE_PFC) || defined (MODE_INTERLEAVED)
  if (PFC_Flags.bits.AGOn)
  {
    mul01 = ((uint32_t) Vout_Control.Reference.Voltage_Loop_Output * GAINSLOPE_HIGHLINE);
    mul02 = (uint16_t) (mul01 >> 15);
    Adaptive_Gain_Factor = GAINOFFSET_HIGHLINE - mul02;
 
    if (Phase_Values_PH1.Phase_Voltage.Filtered < 583) // #define machen    
    {
      mul01 = ((uint32_t) Vout_Control.Reference.Voltage_Loop_Output * GAINSLOPE_LOWLINE);
      mul02 = (uint16_t) (mul01 >> 15);
      Adaptive_Gain_Factor = GAINOFFSET_LOWLINE - mul02;
    }
    if (Adaptive_Gain_Factor < MIN_GAIN_FACTOR)
      Adaptive_Gain_Factor = MIN_GAIN_FACTOR;
  }
  else
  {
    Adaptive_Gain_Factor = 3276; //factor = 0.1
  }
#endif
 
#ifdef MODE_GRID_TIE_INVERTER
  Adaptive_Gain_Factor = 8192; //factor = 0.25 (32676*0.25)
#endif
 
#endif
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------