PFC+LLC实现

60 阅读 0 评论 40 点赞

我是靠谱客的博主震动发箍，最近开发中收集的这篇文章主要介绍PFC+LLC实现，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

http://www.ti.com.cn/cn/lit/an/tidu312/tidu312.pdf

http://www.ti.com.cn/cn/lit/an/slua712/slua712.pdf

Designing a UCD3138 Controlled Interleaved PFCBosheng Sun High Performance Isolated

http://www.st.com/content/ccc/resource/technical/document/application_note/group0/9e/cc/b1/4a/5d/c8/4a/64/DM00333800/files/DM00333800.pdf/jcr:content/translations/en.DM00333800.pdf

https://www.st.com/content/ccc/resource/technical/document/application_note/fa/f1/fe/3d/81/1e/47/45/DM00050692.pdf/files/DM00050692.pdf/jcr:content/translations/en.DM00050692.pdf

http://ww1.microchip.com/downloads/en/AppNotes/01106A.pdf

http://www.ti.com/lit/an/slua079/slua079.pdf

http://www.ti.com/lit/an/slua896/slua896.pdf

http://www.ti.com/lit/ml/slyy131/slyy131.pdf

https://www.ti.com/seclit/ml/slup203/slup203.pdf

http://www.rolfes.org/kevin_rolfes_msee_thesis.pdf

https://www.infineon.com/dgdl/APP_XMC4000_PFC_Example_Code_v1_0.exe?fileId=db3a30433fa3001d013fa46cca63035a

https://www.infineon.com/dgdl/APP_XMC4000_PFC_v1_0.pdf?fileId=db3a30433f74fc8b013f7549c9430047

/*******************************************************************************
Copyright (c) 2013, Infineon Technologies AG **
All rights reserved. **
**
Redistribution and use in source and binary forms, with or without **
modification,are permitted provided that the following conditions are met: **
**
*Redistributions of source code must retain the above copyright notice, **
this list of conditions and the following disclaimer. **
*Redistributions in binary form must reproduce the above copyright notice, **
this list of conditions and the following disclaimer in the documentation **
and/or other materials provided with the distribution. **
*Neither the name of the copyright holders nor the names of its contributors **
may be used to endorse or promote products derived from this software without**
specific prior written permission. **
**
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" **
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE **
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE **
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE **
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR **
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF **
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS **
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN **
CONTRACT, STRICT LIABILITY,OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) **
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE **
POSSIBILITY OF SUCH DAMAGE. **
**
To improve the quality of the software, users are encouraged to share **
modifications, enhancements or bug fixes with Infineon Technologies AG **
dave@infineon.com). **
**
********************************************************************************
** **
** **
** PLATFORM : Infineon XMC4000 Series **
** **
** COMPILER : Compiler Independent **
** **
** AUTHOR : Application Engineering **
** **
** MAY BE CHANGED BY USER [yes/no]: Yes **
** **
** MODIFICATION DATE : Jul 01, 2013 **
** **
*******************************************************************************/
/*******************************************************************************
** Author(s) Identity **
********************************************************************************
** **
** Initials Name **
** ---------------------------------------------------------------------------**
** HLM Application Engineering **
*******************************************************************************/
/**
* @file main.c
* @brief Main.c file for PFC operating in CCM, Avg Current Mode Ctrl
*
*/

/*******************************************************************************
** Include Files **
*******************************************************************************/
/* Inclusion of header file */
#include <DAVE3.h> //Declarations from DAVE3 Code Generation (includes SFR declaration)
#include "GPIO.h"
#include "PFC.h"
#include "arm_math.h"

/*******************************************************************************
** Global Constant Definitions **
*******************************************************************************/
#define HIGH_LINE

#define N_VIN 0.166f
#define N_VOUT 0.166f
#define OUTPUTVOLTAGE_REF 400.0f

#define BLOCK_SIZE 1
#define NUM_TAPS 12

__IO uint32_t *ShadowCompareReg;
__IO uint32_t *ShadowTransfer;
__IO uint32_t *ADCResult_Vin;
__IO uint32_t *ADCResult_Vout;
__IO uint32_t *ADCResult_Current;

/*******************************************************************************
** Global Variable Definitions **
*******************************************************************************/
uint16_t uwInductorCurrent;
uint16_t uwOutputVoltage;
uint16_t uwInputVoltage;
uint16_t FIR_DelayCounter;
uint16_t OverVoltageBit;
uint16_t qADCUpperBound;
uint16_t qADCLowerBound;
uint16_t qOverVoltageCount;
uint16_t qUnderVoltageCount;

float fADCUpperBound;
float fADCLowerBound;

uint32_t blockSize = BLOCK_SIZE;

static float32_t firStateF32[BLOCK_SIZE + NUM_TAPS - 1];

volatile float fOpAmpOffset;

volatile unsigned long timingdelay;

volatile PFC_Coefs_Type PFC;

arm_pid_instance_f32 PI_Current;
arm_pid_instance_f32 PI_Voltage;
arm_fir_instance_f32 sFIR;

/*******************************************************************************
** Private Constant Definitions **
*******************************************************************************/
const float32_t firCoeffs32[NUM_TAPS] =
{0.0056f, 0.0158f, 0.0467f, 0.0967f, 0.1503f, 0.1850f, 0.1850f, 0.1503f, 0.0967f, 0.0467f, 0.0158f, 0.0056f};

/*******************************************************************************
** Public Function Definitions **
*******************************************************************************/
void Delay100us(unsigned long time);

void PFC_Init(void);
void ControlLoop_Init(void);
void Current_Offset_Measurement(void);
void arm_fir_f32_1(const arm_fir_instance_f32 *S, float32_t *pSrc, float32_t *pDst);

/*******************************************************************************
** **
** FUNCTION : int main(void) **
** **
** DESCRIPTION : This is the main function of the PFC code **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

int main(void)
{
// status_t status; // Declaration of return variable for DAVE3 APIs (toggle comment if required)

// at CLK001 App: Set Back Up Clock Trimming Option to "Backup Clock Factory Calibrated"

DAVE_Init(); // Initialization of DAVE Apps

/* Set system timer to 100us */
SysTick_Config(12000);

/* Change the interrupt setting from Period Match to One Match Interrupt. Take note of the CCU4x/CC4x used */
WR_REG(CCU40_CC40->INTE, CCU4_CC4_INTE_PME_Msk, CCU4_CC4_INTE_PME_Pos, 0);
WR_REG(CCU40_CC40->INTE, CCU4_CC4_INTE_OME_Msk, CCU4_CC4_INTE_OME_Pos, 1);

/* Initialize pointers to corresponding registers */
ADCResult_Current = &ADCCH001_Handle0.ADCGrPtr->RES[ADCCH001_Handle0.kEndResultRegNo];
ADCResult_Vout = &ADCCH001_Handle1.ADCGrPtr->RES[ADCCH001_Handle1.kEndResultRegNo];
ADCResult_Vin = &ADCCH001_Handle2.ADCGrPtr->RES[ADCCH001_Handle2.kEndResultRegNo];
ShadowCompareReg = &PWMSP001_Handle0.CC4yRegsPtr->CRS;
ShadowTransfer = &PWMSP001_Handle0.CC4yKernRegsPtr->GCSS;

/* Initialize ADC Queue */
ADC002_InitializeQueue(&ADC002_Handle0);

/* Set Output Voltage Lower and Higher Boundary for STARTUP OPERATION */
fADCUpperBound = 480.0f / N_VOUT;
fADCLowerBound = 0.0f / N_VOUT;
qADCUpperBound = (uint32_t) fADCUpperBound;
qADCLowerBound = (uint32_t) fADCLowerBound;

/* Set Output Voltage Upper Boundary (Boundary1) and Lower Boundary (Boundary0) */
WR_REG(ADCGROUP001_Handle0.VADCGroupPtr->BOUND, VADC_G_BOUND_BOUNDARY1_Msk, VADC_G_BOUND_BOUNDARY1_Pos, qADCUpperBound);
WR_REG(ADCGROUP001_Handle0.VADCGroupPtr->BOUND, VADC_G_BOUND_BOUNDARY0_Msk, VADC_G_BOUND_BOUNDARY0_Pos, qADCLowerBound);

/* Initialize Current Loop PI controller coefficients AC-DC Converter */
PI_Current.Kp = 0.0f;
PI_Current.Ki = 0.0f;
PI_Current.Kd = 0.0f;
arm_pid_init_f32(&PI_Current, 1);

/* Initialize Voltage Loop PI controller coefficients */
PI_Voltage.Kp = 0.0;
PI_Voltage.Ki = 0.0;
PI_Voltage.Kd = 0.0;
arm_pid_init_f32(&PI_Voltage, 1);

/* Start CCU4 Slices */
PWMSP001_Start(&PWMSP001_Handle0);
PWMSP001_Start(&PWMSP001_Handle1);

/* Delay 500ms to wait for OpAmp output to stabilize */
Delay100us(5000);

/* Measure OpAmp Offset */
Current_Offset_Measurement();

/* Initialize PFC variables */
PFC_Init();

/* Enable Period Match and Compare Match interrupts for Voltage and Current Loop */
NVIC002_EnableIRQ(&NVIC002_Handle0);
NVIC002_EnableIRQ(&NVIC002_Handle1);

/* Delay 50ms to wait for FIR filter to stabilise */
Delay100us(500);

/* Initialize PI controllers coefficients for Voltage and Current Loops */
ControlLoop_Init();

/* Enable Overvoltage Interrupt */
NVIC002_EnableIRQ(&NVIC002_Handle2);

/* Delay until PFC Steady State operation is reached */
Delay100us(5000);
Delay100us(5000);

/* Set Output Voltage Lower and Higher Boundary for STEADY STATE OPERATION */
fADCUpperBound = 450.0f / N_VOUT;
fADCLowerBound = 370.0f / N_VOUT;
qADCUpperBound = (uint32_t) fADCUpperBound;
qADCLowerBound = (uint32_t) fADCLowerBound;

/* Set Output Voltage Upper Boundary (Boundary1) and Lower Boundary (Boundary0) */
WR_REG(ADCGROUP001_Handle0.VADCGroupPtr->BOUND, VADC_G_BOUND_BOUNDARY1_Msk, VADC_G_BOUND_BOUNDARY1_Pos, qADCUpperBound);
WR_REG(ADCGROUP001_Handle0.VADCGroupPtr->BOUND, VADC_G_BOUND_BOUNDARY0_Msk, VADC_G_BOUND_BOUNDARY0_Pos, qADCLowerBound);

while(1)
{

}
return 0;
}

/*******************************************************************************
** **
** FUNCTION : void PeriodMatch_INT(void) **
** **
** DESCRIPTION : This is the Interrupt Service Routine for **
** CCU4 Period Match event. It is used for Current Loop **
** and updating PWM duty cycle. **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void PeriodMatch_INT(void)
{
volatile uint16_t tempInductorCurrent;

/* Read Input Voltage */
PFC.qVin = *ADCResult_Vin;
PFC.fVin = (float)PFC.qVin * PFC.fN_Vin;

/* Read Inductor Current */
tempInductorCurrent = *ADCResult_Current;
PFC.fIpfc = (float)tempInductorCurrent;
PFC.fIpfc = PFC.fIpfc - fOpAmpOffset;

/* Calculate Current Command */
PFC.fCurrentCmdOut = PFC.fVin * PFC.fInvSqr * PFC.fPI_VoltageOut;

/* Current Loop Calculation for AC-DC Converter */
PFC.fPI_CurrentOut = arm_pid_f32(&PI_Current, (PFC.fCurrentCmdOut - PFC.fIpfc));

if (OverVoltageBit == 0)
{
/* Update PWM for Current Control */
*ShadowCompareReg = (uint16_t) (PFC.fPI_CurrentOut);

/* Limit PWM duty cycle */
if(*ShadowCompareReg > PFC.qPWM_Current_MAX)
{
*ShadowCompareReg = PFC.qPWM_Current_MAX;
}
}
else
{
/* Turn off PWM */
*ShadowCompareReg = 0;
}

/* Enable Shadow Transfer for Slice 0 */
*ShadowTransfer = 0x01;
}

/*******************************************************************************
** **
** FUNCTION : void CompareMatch_INT(void) **
** **
** DESCRIPTION : This is the Interrupt Service Routine for **
** CCU4 Compare Match event. It is used for Output Voltage **
** Loop and Feedforward Filter **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void CompareMatch_INT(void)
{
/* Read Output Voltage */
PFC.qVout = *ADCResult_Vout;
PFC.fVout = (float)PFC.qVout * PFC.fN_Vout;

/* Voltage Loop Calculation */
PFC.fPI_VoltageOut = arm_pid_f32(&PI_Voltage, (PFC.fVoltageRef - PFC.fVout));

/* FIR filter */
FIR_DelayCounter--;
while(FIR_DelayCounter == 0)
{
/* FIR Filter */
arm_fir_f32_1(&sFIR, &PFC.fVin, &PFC.fFilterResult);

/* Calculate Inverse Square */
PFC.fInvSqr = 1.0f / (PFC.fFilterResult * PFC.fFilterResult);
FIR_DelayCounter = 40;
}
}

/*******************************************************************************
** **
** FUNCTION : void Overvoltage_INT(void) **
** **
** DESCRIPTION : This is the Interrupt Service Routine for **
** VADC Channel Event Interrupt. It is used as overvoltage **
** handler. **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void Overvoltage_INT(void)
{
/* Upper Boundary Interrupt */
if ((PFC.qVout > qADCUpperBound) && !OverVoltageBit)
{
/* Sample OverVoltage Interrupt occurrence for 500 times (5ms) */
qOverVoltageCount++;

if (qOverVoltageCount > 500)
{
/* Turn On OverVoltage Bit */
OverVoltageBit = 1;

/* Reset PI Controllers */
arm_pid_reset_f32(&PI_Current);
arm_pid_reset_f32(&PI_Voltage);

/* Reset OverVoltage Counter */
qOverVoltageCount = 0;
}
}

/* Lower Boundary Interrupt */
else if ((PFC.qVout < qADCLowerBound) && OverVoltageBit)
{
/* Sample UnderVoltage Interrupt occurrence for 500 times (5ms) */
qUnderVoltageCount++;

if(qUnderVoltageCount > 500)
{
/* Turn Off OverVoltage Bit */
OverVoltageBit = 0;

/* Enable PI Controllers */
ControlLoop_Init();

/* Reset UnderVoltage Counter */
qUnderVoltageCount = 0;
}
}
}

/*******************************************************************************
** **
** FUNCTION : void PFC_Init(void) **
** **
** DESCRIPTION : This function is to initialize PFC parameters and **
** Feedforward Filter **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void PFC_Init(void)
{
/* Initialize FIR Filter */
arm_fir_init_f32(&sFIR, NUM_TAPS, (float32_t *)&firCoeffs32[0], &firStateF32[0], blockSize);

/* Assign values to PFC struct */
PFC.fN_Vin = N_VIN;
PFC.fN_Vout = N_VOUT;
PFC.fVoltageRef = OUTPUTVOLTAGE_REF;
FIR_DelayCounter = 40;

/* Determine Maximum Duty Cycle from CCU4 Period Register. In this case it is 80% */
PFC.qPWM_Current_MAX = (PWMSP001_Handle0.CC4yRegsPtr->PRS * 9.6) / 10;

/* Initialize OverVoltage Conditions to 0 during startup */
OverVoltageBit = 0;
qOverVoltageCount = 0;
qUnderVoltageCount = 0;
}

/*******************************************************************************
** **
** FUNCTION : void ControlLoop_Init(void) **
** **
** DESCRIPTION : This function is to initialize Current and Voltage Loop **
** Parameters (Kp and Ki) **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void ControlLoop_Init(void)
{
#ifdef HIGH_LINE
/* Initialize Current Loop PI controller coefficients AC-DC Converter */
PI_Current.Kp = 0.036f/2; /* high line */
PI_Current.Ki = 0.02f/2; /* high line */
PI_Current.Kd = 0.0f;
arm_pid_init_f32(&PI_Current, 1);

/* Initialize Voltage Loop PI controller coefficients */
PI_Voltage.Kp = 0.01f; /* high line */
PI_Voltage.Ki = 0.04f*15; /* high line */
PI_Voltage.Kd = 0.0f;
arm_pid_init_f32(&PI_Voltage, 1);
#else
/* Initialize Current Loop PI controller coefficients AC-DC Converter */
PI_Current.Kp = 0.04/2; /* low line */
PI_Current.Ki = 0.022/10; /* low line */
PI_Current.Kd = 0.0f;
arm_pid_init_f32(&PI_Current, 1);

/* Initialize Voltage Loop PI controller coefficients */
PI_Voltage.Kp = 0.01f/4; /* low line */
PI_Voltage.Ki = 0.04f*10; /* low line */
PI_Voltage.Kd = 0.0f;
arm_pid_init_f32(&PI_Voltage, 1);
#endif
}

/*******************************************************************************
** **
** FUNCTION : void Current_Offset_Measurement(void) **
** **
** DESCRIPTION : This function is to measure the Current Op-Amp Offset **
** in the beginning **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void Current_Offset_Measurement(void)
{
uint16_t MeasurementCount = 0;
uint32_t ulOpAmpOffset = 0;

while (MeasurementCount < 32)
{
/* Read Inductor Current from ADC Result Register */
ADCCH001_GetResult(&ADCCH001_Handle0, &uwInductorCurrent);

/* Accumulate Inductor Current reading for 32 times */
ulOpAmpOffset += (uwInductorCurrent & 0x0FFF);
MeasurementCount++;
}

/* Find the Op-Amp Current Sense average by dividing the accumulated readings */
fOpAmpOffset = (float)ulOpAmpOffset / 32.0;
}

/*******************************************************************************
** **
** FUNCTION : void Delay100us(unsigned long time) **
** **
** DESCRIPTION : This function produces 100us delay time **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void Delay100us(unsigned long time)
{
unsigned long t, m;

timingdelay = time;
for(t = timingdelay; t>0; t--)
{
for(m = 1000; m>0; m--);
}
}

void SysTick_Handler(void)
{
if(timingdelay != 0)
{
timingdelay--;
}
}

/*******************************************************************************
** **
** FUNCTION : void arm_fir_f32_1( , , ) **
** **
** DESCRIPTION : This is Feedfoward Filter function **
** **
** VERSION : 1.0.0 (Initial version) **
** **
** DATE : Jul 01, 2013 **
** **
*******************************************************************************/

void arm_fir_f32_1(const arm_fir_instance_f32 * S, float32_t * pSrc, float32_t * pDst)
{
float32_t *pState = S->pState; /* State pointer */
float32_t *pCoeffs = S->pCoeffs; /* Coefficient pointer */
float32_t *pStateCurnt; /* Points to the current sample of the state */
float32_t *px, *pb; /* Temporary pointers for state and coefficient buffers */
uint32_t numTaps = S->numTaps; /* Number of filter coefficients in the filter */
uint32_t i, tapCnt; /* Loop counters */

float32_t acc0; /* Accumulators */

/* S->pState points to state array which contains previous frame (numTaps - 1) samples */
/* pStateCurnt points to the location where the new input data should be written */
pStateCurnt = &(S->pState[(numTaps - 1u)]);

/* Copy one sample at a time into state buffer */
*pStateCurnt++ = *pSrc++;

/* Set the accumulator to zero */
acc0 = 0.0f;

/* Initialize state pointer */
px = pState;

/* Initialize Coefficient pointer */
pb = (pCoeffs);

i = numTaps;

/* Perform the multiply-accumulates */
do
{
acc0 += *px++ * *pb++;
i--;

} while(i > 0u);

/* The result is store in the destination buffer. */
*pDst++ = acc0;

/* Advance state pointer by 1 for the next sample */
pState = pState + 1;

/* Processing is complete.
** Now copy the last numTaps - 1 samples to the satrt of the state buffer.
** This prepares the state buffer for the next function call. */

/* Points to the start of the state buffer */
pStateCurnt = S->pState;

tapCnt = (numTaps - 1u) >> 2u;

/* copy data */
while(tapCnt > 0u)
{
*pStateCurnt++ = *pState++;
*pStateCurnt++ = *pState++;
*pStateCurnt++ = *pState++;
*pStateCurnt++ = *pState++;

/* Decrement the loop counter */
tapCnt--;
}

/* Calculate remaining number of copies */
tapCnt = (numTaps - 1u) % 0x4u;

/* Copy the remaining q31_t data */
while(tapCnt > 0u)
{
*pStateCurnt++ = *pState++;

/* Decrement the loop counter */
tapCnt--;
}
}