⛄️ 👧🏼 👧🏽 Buck-Boost-Wandler mit digitaler Steuerung am STM32F334 im CC / CV-Modus 🖥️ 📱 🐭

Die beliebtesten DC / DC-Topologien Buck und Boost haben eine erhebliche Einschränkung: Die Buck-Topologie kann nur die Eingangsspannung reduzieren, während die Boost-Topologie sie nur erhöht. Es gibt jedoch Aufgaben, bei denen der Eingangsspannungsbereich einen gleichzeitigen Betrieb zum Erhöhen und Verringern erfordert. Beispielsweise haben wir einen Eingang von 3 ... 15 V, und am Ausgang ist es erforderlich, stabilisierte 12 V zu erhalten. Vertraute Situation?

Es gibt 2 mögliche Lösungen:

Erhöhen Sie mit dem Aufwärtswandler die Eingangsspannung von 3 ... 15 V auf stabile 15 V am Ausgang und senken Sie dann mithilfe der Buck-Topologie die Spannung auf die erforderlichen 12 V ab.
Wenden Sie eine Buck-Boost-Topologie an, die dieses Problem optimal löst.

Ein offensichtlicher Nachteil des ersten Verfahrens ist die Notwendigkeit, 2 Drosseln, eine erhöhte Anzahl von Kondensatoren und nicht die optimalste Betriebsart zu verwenden, was einen geringeren Wirkungsgrad bedeutet. Die Buck-Boost-Topologie weist diese Nachteile nicht auf, daher werden wir heute darüber sprechen. Um es interessant zu machen, entschied ich mich, keinen vorgefertigten Controller zu nehmen und implementierte einen digital gesteuerten DC / DC-Wandler basierend auf STM32F334C8T6.

Das Ergebnis der Arbeit für diejenigen, die die Textwand nicht lesen wollen

Im Rahmen dieses Artikels werde ich kurz auf die Hardware-Implementierung des Konverters und die Implementierung eines Steuerungssystems für verschiedene Betriebsarten eingehen. Interessant? Dann lass uns gehen ...

1. Kurz über den Betrieb der Buck-Boost-Topologie

: 2 2 , .. , 2 (4 ). , . :

, : 2 ( 2 , ), 4 , . 1 2 (OCP) . 2 ? , , .

, , , STM32F334, STM32G474, XMC4108, TMS320F28027 , .. : HRPWM, , , . , , , . , , , (OCP) , , .

… buck-boost :

buck () boost (), — 3 buck-, L1C3 LC-. 3 boost-, . , buck-, boost-. .

buck:

V_{o u t} = V_{i n} * D

$V_{out} = V_{in} * D$

boost:

V_{o u t} = \frac{V_{i n}}{(1 - D)}

$V_{out} = \frac{V_{in}} {(1 - D)}$

, buck- boost :

V_{o u t - b o o s t} = \frac{V_{i n - b u c k} * D_{b u c k}}{1 - D_{b o o s t}}

$V_{out-boost} = \frac{V_{in-buck} * D_{buck}} {1 - D_{boost}}$

buck-boost 3- : ( PWM-BUCK PWM-BOOST). , .

, . , 8, D_boost 70%, D_buck 50%. :

V_{o u t - b o o s t} = \frac{V_{i n - b u c k} * D_{b u c k}}{1 - D_{b o o s t}} = \frac{8 V * 0, 5}{1 - 0, 7} = 13, 33 V

$V_{out-boost} = \frac{V_{in-buck} * D_{buck}} {1 - D_{boost}} = \frac{8V * 0,5} {1 - 0,7} = 13,33V$

, 8 . , , , 2 - :

Oszilloskop-Diagramm

. (duty) 2- . duty, .

2. .

2 , : . , , CC/CV . :

Steuerblockdiagramm

CC CV , : REF , , ; , , , , .

-, , " " . "" (REF), , , 10. , buck-boost , (duty). - . , .

e r r o r = V_{r e f e r e n c e} - V_{o u t}

$error = V_{reference} - V_{out}$

Was gibt es uns? Und jetzt wissen wir, um wie viel der reale Wert der Ausgangsspannung vom eingestellten Wert ( REF ) abgewichen ist . Dies ermöglicht es uns zu verstehen, ob es notwendig ist, "einen Befehl zu geben", um die Spannung zu erhöhen oder zu verringern. Um beispielsweise in der Buck- Topologie die Spannung zu erhöhen, müssen Sie die Leistung des oberen Transistors erhöhen und die Füllung entsprechend verringern, um die Spannung zu verringern. Für die Boost- Topologie hingegen und für den Buck-Boost gibt es 2 Signale, und hier ist es bereits schwieriger - Sie müssen das Gleichgewicht halten, aber ich denke, im Durchschnitt ist die Idee klar. Aus Gründen der Klarheit werde ich einen Pseudocode zur Steuerung des Buck geben :

//      -
uint16_t dutyPWM = 0;

//  ,     
const float referenceOutputVoltage = 10.0f;

//    , ,  1 
void sTim3::handler (void) {
    float outputVoltage = GetOutputVoltage();
    if (outputVoltage > referenceOutputVoltage) {
        dutyPWM--;
    } else {
        dutyPWM++;
    }
}

, . - ( ), , -, -:

//      -
uint16_t dutyPWM = 0;

//  ,     
const float referenceOutputVoltage = 10.0f;

//    
const float Kp = 1.0f;

//    , ,  1 
void sTim3::handler (void) {
    float outputVoltage = GetOutputVoltage();
    float error = referenceOutputVoltage - outputVoltage;
    dutyPWM += Kp * error;
}

… , , (dutyPWM) buck , , . , (reference), dutyPWM .

, 1 , . error -. , dutyPWM .

buck dc/dc , 20. dutyPWM 0, 1000, buck V_out = V_in x dutyPWM = 20V x 0 = 0V, 0. ( №1) error = 10 — 0 = 10 dutyPWM = 10, V_out = V_in x dutyPWM = 20V x (10/1000) = 0.2V. 1 ( №2) error = 10 — 0.2V = 9.8V, dutyPWM = 19.8, (reference). , reference 10 ( ).

Kp, , . 1, . , 0.2 . () , , . Kp 10 : dutyPWM = Kp x error = 10 x (10 — 0) = 100, 0.2, V_out = V_in x dutyPWM = 20V x (100/1000) = 2V, " " 10 . Kp . , , , , .

… ? , .

3. CV mode

CV mode, . ( ), , , : - ++. , . , .

STM32F334C8T6, , HRPWM . , , . , (2-3-4) , , .

CV :

/***********************************************************
*       200 ,
*    HRPWM    - 30 000.
*     : 3...15
*    : 20 
*
*      : 12
***********************************************************/

void sTim3::handler (void) {
    TIM3->SR &= ~TIM_SR_UIF;

    float inputVoltage = Feedback::GetInputVoltage();

    //   boost,  Vin < 90% * Vref
    if (inputVoltage <= (Application::referenceOutputVoltage * 0.9)) {
        Hrpwm::SetDuty(Hrpwm::Channel::buck, 29000);
        float outputVoltage = Feedback::GetOutputVoltage();

        pidVoltageMode
            .SetReference(Application::referenceOutputVoltage)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputVoltage, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBoost += pidVoltageMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::boost, Application::dutyBoost);
    }

    //   buck,  Vin > Vref * 110%
    if (inputVoltage >= (Application::referenceOutputVoltage * 1.1)) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 1000);
        float outputVoltage = Feedback::GetOutputVoltage();

        pidVoltageMode
            .SetReference(Application::referenceOutputVoltage)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputVoltage, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBuck += pidVoltageMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }

    //   buck-boost,  (90% * Vref) < Vin < (110% * Vref)
    if ((inputVoltage > (Application::referenceOutputVoltage * 0.9)) && (inputVoltage < (Application::referenceOutputVoltage * 1.1))) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 6000);
        float outputVoltage = Feedback::GetOutputVoltage();

        pidVoltageMode
            .SetReference(Application::referenceOutputVoltage)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputVoltage, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBuck += pidVoltageMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }    
}

… buck-boost, , 2- buck boost . 2- : . , , , .

/***********************************************************
*       200 ,
*    HRPWM    - 30 000.
*     : 3...15
*    : 20 
*
*      : 12
***********************************************************/

void sTim3::handler (void) {
    TIM3->SR &= ~TIM_SR_UIF;

    //          boost
    float inputVoltage = Feedback::GetInputVoltage();
    if (inputVoltage < 6.0f) { Application::dutyBoost = 25000; }
    if ((inputVoltage >= 6.0f) && (inputVoltage < 12.0f)) { Application::dutyBoost = 18000; }
    if (inputVoltage >= 12.0f) { Application::dutyBoost = 6000; }
    Hrpwm::SetDuty(Hrpwm::Channel::boost, Application::dutyBoost);

    //         buck 
    float outputVoltage = Feedback::GetOutputVoltage();

    pidVoltageMode
        .SetReference(Application::referenceOutputVoltage)
        .SetSaturation(-29800, 29800)
        .SetFeedback(outputVoltage, 0.001)
        .SetCoefficient(10,0,0,0,0)
        .Compute();

    Application::dutyBuck += pidVoltageMode.Get();
    Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);    
}

3 : 3...6, 6...12 12...15 boost , buck. , — , . , ( ), .

3 , , , , . dutyBoost : , buck boost-, 90% ( ). , 3...15 . dutyBoost — 3 15, , .. . dutyBuck 90% 3 "" boost- 3 x 0,9 = 2,7, boost 15 2.7! dutyBoost 1 — (V_out / V_in) = 1 — 2,7 / 15 = 82%, , - 30000, 30 000 x 82% = 24 600, 25000.

3, 5, buck 3. , dutyBoost, buck 90% 12. , ~3,2% . ? , , "" .

6...12 60% 18000, 12...15 20% 6000. - ...

3- . , , buck 100% boost-, boost dc/dc . , , — boost- 0% buckDuty, buck dc/dc . — , buck, boost buck-boost...

boost , "" 90% , V_ref x 90% = 12 x 0,9 = 10,8. dutyBoost = 1 — (V_ref x 90%) / (V_ref x 110%) = 1 — 0,9 / 1,1 = 19% = 5700, 6000 . buck- buckDuty. "" buck-boost , . , :

4. CC mode

, . , , , LED, - , . , dc/dc , .. (duty), ?

— : U = I x R. , , , 10 . dc/dc 10 , I = U / R = 1, , .. . Li-ion , , 15, - 5, . , , I = U / R = const.

, , , . , , , I = U / R = const.

, 1. 1 1: I = 1 = const = U / R = 1 / 1 . 5 , 5: I = 1 = const = U / R = 5 / 5 . 5, 1 0.2 .

, , (error) , (dutyPWM). :


/***********************************************************
*       200 ,
*    HRPWM    - 30 000.
*     : 3...15
*    : 20 
*
*      : 1
***********************************************************/

void sTim3::handler (void) {
    TIM3->SR &= ~TIM_SR_UIF;

    float inputVoltage = Feedback::GetInputVoltage();

    //   boost,  Vin < 90% * Vref
    if (inputVoltage <= (Application::referenceOutputVoltage * 0.9)) {
        Hrpwm::SetDuty(Hrpwm::Channel::buck, 29000);
        float outputCurrent = Feedback::GetOutputCurrent();

        pidCurrentMode
            .SetReference(Application::referenceOutputCurrent)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputCurrent, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBoost += pidCurrentMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::boost, Application::dutyBoost);
    }

    //   buck,  Vin > Vref * 110%
    if (inputVoltage >= (Application::referenceOutputVoltage * 1.1)) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 1000);
        float outputCurrent = Feedback::GetOutputCurrent();

        pidCurrentMode
            .SetReference(Application::referenceOutputCurrent)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputCurrent, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBuck += pidCurrentMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }

    //   buck-boost,  (90% * Vref) < Vin < (110% * Vref)
    if ((inputVoltage > (Application::referenceOutputVoltage * 0.9)) && (inputVoltage < (Application::referenceOutputVoltage * 1.1))) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 6000);
        float outputCurrent = Feedback::GetOutputCurrent();

         pidCurrentMode
            .SetReference(Application::referenceOutputCurrent)
            .SetSaturation(-29800, 29800)
            .SetFeedback(outputCurrent, 0.001)
            .SetCoefficient(10,0,0,0,0)
            .Compute();

        Application::dutyBuck += pidCurrentMode.Get()
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }    
}

, buck-boost . , (outputCurrent) - (referenceOutputCurrent) , , . :

e r r o r = I_{r e f e r e n c e} - I_{o u t}

$error = I_{reference} - I_{out}$

, CV mode. - , 2 : , , , .

LED 10 1, :

5. CC/CV mode

, … :

10 Li-ion , , . , , ( ) , .

1, Li-ion , . … ? , , , , , — .

- , ? CC/CV, . : 1 Li-ion 4.2 , CC/CV 3...15 1. , 1 , CC , . , 15, CV, 15 ( ).

2 , .. , 15 , , 1 — , . 3, , , CV , . , :


/***********************************************************
*       200 ,
*    HRPWM    - 30 000.
*     : 3...15
*    : 20 
*
*      : 10 1
***********************************************************/

void sTim3::handler (void) {
    TIM3->SR &= ~TIM_SR_UIF;

    float resultPID = 0.0f;

    float inputVoltage = Feedback::GetInputVoltage();

    //   boost,  Vin < 90% * Vref
    if (inputVoltage <= (Application::referenceOutputVoltage * 0.9)) {
        Hrpwm::SetDuty(Hrpwm::Channel::buck, 29000);

        float outputVoltage = Feedback::GetOutputVoltage();
        float outputCurrent = Feedback::GetOutputCurrent();

        //   CC mode,  Vout < Vref
        if (outputVoltage < (Application::referenceOutputVoltage - 0.2f)) {
            pidCurrentMode
                .SetReference(Application::referenceOutputCurrent)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputCurrent, 0.001)
                .SetCoefficient(20,0,0,0,0)
                .Compute();
            resultPID = pidCurrentMode.Get();
        }

        //   CV mode,  (Iout -> 0)  (Vout => Vref)
        if ((outputCurrent < 0.05f) || (outputVoltage >= (Application::referenceOutputVoltage - 0.2f))) {
            pidVoltageMode
                .SetReference(Application::referenceOutputVoltage)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputVoltage, 0.001)
                .SetCoefficient(50,0,0,0,0)
                .Compute();
            resultPID = pidVoltageMode.Get();
        }

        Application::dutyBoost += resultPID;
        Hrpwm::SetDuty(Hrpwm::Channel::boost, Application::dutyBoost);
    }

    //   buck,  Vin > Vref * 110%
    if (inputVoltage >= (Application::referenceOutputVoltage * 1.1)) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 1000);

        float outputVoltage = Feedback::GetOutputVoltage();
        float outputCurrent = Feedback::GetOutputCurrent();

        //   CC mode,  Vout < Vref
        if (outputVoltage < (Application::referenceOutputVoltage - 0.2f)) {
            pidCurrentMode
                .SetReference(Application::referenceOutputCurrent)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputCurrent, 0.001)
                .SetCoefficient(20,0,0,0,0)
                .Compute();
            resultPID = pidCurrentMode.Get();
        }

        //   CV mode,  (Iout -> 0)  (Vout => Vref)
        if ((outputCurrent < 0.05f) || (outputVoltage >= (Application::referenceOutputVoltage - 0.2f))) {
            pidVoltageMode
                .SetReference(Application::referenceOutputVoltage)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputVoltage, 0.001)
                .SetCoefficient(50,0,0,0,0)
                .Compute();
            resultPID = pidVoltageMode.Get();
        }

        Application::dutyBuck += resultPID;
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }

    //   buck-boost,  (90% * Vref) < Vin < (110% * Vref)
    if ((inputVoltage > (Application::referenceOutputVoltage * 0.9)) && (inputVoltage < (Application::referenceOutputVoltage * 1.1))) {
        Hrpwm::SetDuty(Hrpwm::Channel::boost, 6000);

        float outputVoltage = Feedback::GetOutputVoltage();
        float outputCurrent = Feedback::GetOutputCurrent();

        //   CC mode,  Vout < Vref
        if (outputVoltage < (Application::referenceOutputVoltage - 0.2f)) {
            pidCurrentMode
                .SetReference(Application::referenceOutputCurrent)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputCurrent, 0.001)
                .SetCoefficient(20,0,0,0,0)
                .Compute();
            resultPID = pidCurrentMode.Get();
        }

        //   CV mode,  (Iout -> 0)  (Vout => Vref)
        if ((outputCurrent < 0.05f) || (outputVoltage >= (Application::referenceOutputVoltage - 0.2f))) {
            pidVoltageMode
                .SetReference(Application::referenceOutputVoltage)
                .SetSaturation(-29800, 29800)
                .SetFeedback(outputVoltage, 0.001)
                .SetCoefficient(50,0,0,0,0)
                .Compute();
            resultPID = pidVoltageMode.Get();
        }

        Application::dutyBuck += resultPID;
        Hrpwm::SetDuty(Hrpwm::Channel::buck, Application::dutyBuck);
    }    
}

, , if, . .

, 2 -, , — -. CC mode CV mode. : (Application::referenceOutputVoltage) , CV mode, 15. , CC mode 1.

, / , . , LED 2 . , , 10 STM32F334 .

buck-boost dc/dc CC/CV:

...

lamerok veydlin, (, , ), !

, : https://t.me/proHardware. , , , , , .

, . buck-boost-, , , - , .

Buck-Boost-Wandler mit digitaler Steuerung am STM32F334 im CC / CV-Modus

1. Kurz über den Betrieb der Buck-Boost-Topologie

2. .

3. CV mode

4. CC mode

5. CC/CV mode

...

More articles: