Einfache Induktivitätsauswahl für Buck-Regler mit Python

#!/usr/bin/env python3
from UliEngineering.Electronics.SwitchingRegulator import *
from UliEngineering.EngineerIO import *

Vin = normalize_numeric("48V")
Vout = normalize_numeric("24V")
fsw = normalize_numeric("750kHz")
Ioutmax = normalize_numeric("5A")

#
# Optionale Parameter
#

# Wie viel Ripple-Spannung ist akzeptabel?
# Die Ausgangsspannung wird um 1/2 der Ripple-Spannung
# auf jeder Seite der durchschnittlichen Ausgangsspannung schwingen
# Im Zweifel verwende 0.04 * Vout (konservativ)
# Ein größerer Wert erleichtert die Suche
# nach geeigneten Bauteilen
output_voltage_ripple = 0.01 * Vout

# Schalter-Stromgrenzen.
# Suche die min/nom/max Schalter-Stromgrenzen im Datenblatt!
# Dies ist für jedes IC unterschiedlich und es gibt keine gute Möglichkeit zum Raten!
# Wenn du nur Nennwerte hast, setze min auf Nennwert*85% und max auf Nennwert*120%
# um Temperaturkoeffizienten und Toleranzen zu berücksichtigen.
min_switch_current = 6.3
max_switch_current = 8.8

# Leichtlaststrom wird zur Berechnung der Kapazität verwendet
# Du kannst 5% des maximalen Ausgangsstroms verwenden, wenn du unsicher bist
light_load_current = 0.05 * Ioutmax

# Sicherheitsfaktoren
# Überschreitung des Sättigungsstrom-Nennwerts der Induktivität
# führt bei Ferritkern-Induktivitäten zu harter Sättigung.
# Daher sollte dieser Sicherheitsfaktor konservativ sein (z.B. 20% = 1.2)
saturation_curent_rating_safety_factor = 1.2
# Der RMS-Strom-Nennwert beeinflusst nur das thermische Verhalten
# Daher kann dieser Sicherheitsfaktor niedriger sein (z.B. 10% = 1.1)
rms_current_rating_safety_factor = 1.1
# Empfohlener Ripple-Strom-Nennwert
# Sicherheitsfaktor für die Ausgangskondensatoren
# (angewendet auf den berechneten Induktivitäts-Ripplestrom)
# Dies ist ein thermischer Bewertungsfaktor.
output_capacitor_ripple_current_safety_factor = 1.1

#
# ENDE DER PARAMETER
#

abs_max_inductance = buck_regulator_inductance(Vin, Vout, fsw, Ioutmax, K=0.1)
max_inductance = buck_regulator_inductance(Vin, Vout, fsw, Ioutmax, K=0.2)
optimal_inductance = buck_regulator_inductance(Vin, Vout, fsw, Ioutmax, K=0.3)
min_inductance = buck_regulator_inductance(Vin, Vout, fsw, Ioutmax, K=0.4)

# Eine weitere minimale Induktivität basierend auf dem Wunsch, subharmonische Oszillation zu vermeiden
# Dies hängt stark vom verwendeten IC ab, siehe Datenblatt für weitere Informationen
# Beispiel ist für LMR36006 von Texas Instruments
min_inductance_osc = 0.28 * Vout/fsw

# Spitzen-, RMS- und Ripple-Strom für die verschiedenen Induktivitäten berechnen
abs_max_inductance_current = buck_regulator_inductor_current(
    Vin, Vout, abs_max_inductance, fsw, Ioutmax
)
max_inductance_current = buck_regulator_inductor_current(
    Vin, Vout, max_inductance, fsw, Ioutmax
)
optimal_inductance_current = buck_regulator_inductor_current(
    Vin, Vout, optimal_inductance, fsw, Ioutmax
)
min_inductance_current = buck_regulator_inductor_current(
    Vin, Vout, min_inductance, fsw, Ioutmax
)

# Sättigungsstrom-Nennwert für die Induktivitäten berechnen
abs_max_inductance_rms_current = abs_max_inductance_current.rms * saturation_curent_rating_safety_factor
max_inductance_rms_current = max_inductance_current.rms * saturation_curent_rating_safety_factor
optimal_inductance_rms_current = optimal_inductance_current.rms * saturation_curent_rating_safety_factor
min_inductance_rms_current = min_inductance_current.rms * saturation_curent_rating_safety_factor

# RMS-(thermischen) Strom-Nennwert für die verschiedenen Induktivitäten berechnen
abs_max_inductance_rms_current = abs_max_inductance_current.rms * rms_current_rating_safety_factor
max_inductance_rms_current = max_inductance_current.rms * rms_current_rating_safety_factor
optimal_inductance_rms_current = optimal_inductance_current.rms * rms_current_rating_safety_factor
min_inductance_rms_current = min_inductance_current.rms * rms_current_rating_safety_factor

# Spitzen-Induktorstrom-Nennwert berechnen
abs_max_inductance_peak_current = abs_max_inductance_current.peak
max_inductance_peak_current = max_inductance_current.peak
optimal_inductance_peak_current = optimal_inductance_current.peak
min_inductance_peak_current = min_inductance_current.peak

# Ripple-Strom für jeden Induktivitätswert berechnen
abs_max_inductance_ripple = buck_regulator_inductor_ripple_current(Vin, Vout, abs_max_inductance, fsw, Ioutmax)
max_inductance_ripple = buck_regulator_inductor_ripple_current(Vin, Vout, max_inductance, fsw, Ioutmax)
optimal_inductance_ripple = buck_regulator_inductor_ripple_current(Vin, Vout, optimal_inductance, fsw, Ioutmax)
min_inductance_ripple = buck_regulator_inductor_ripple_current(Vin, Vout, min_inductance, fsw, Ioutmax)

# Minimale Kapazität berechnen, die erforderlich ist, um den Ausgangsspannungs-Ripple zu erreichen
abs_max_inductance_capacitance = buck_regulator_min_capacitance(
    abs_max_inductance_ripple,
    output_voltage_ripple,
    fsw,
    abs_max_inductance,
    Vout,
    Ioutmax,
    light_load_current
)

max_inductance_capacitance = buck_regulator_min_capacitance(
    max_inductance_ripple,
    output_voltage_ripple,
    fsw,
    max_inductance,
    Vout,
    Ioutmax,
    light_load_current
)

optimal_inductance_capacitance = buck_regulator_min_capacitance(
    optimal_inductance_ripple,
    output_voltage_ripple,
    fsw,
    optimal_inductance,
    Vout,
    Ioutmax,
    light_load_current
)

min_inductance_capacitance = buck_regulator_min_capacitance(
    min_inductance_ripple,
    output_voltage_ripple,
    fsw,
    min_inductance,
    Vout,
    Ioutmax,
    light_load_current
)

# Maximalen ESR des Kondensators berechnen
abs_max_inductance_esr = buck_regulator_output_capacitor_max_esr(output_voltage_ripple, abs_max_inductance_ripple)
max_inductance_esr = buck_regulator_output_capacitor_max_esr(output_voltage_ripple, max_inductance_ripple)
optimal_inductance_esr = buck_regulator_output_capacitor_max_esr(output_voltage_ripple, optimal_inductance_ripple)
min_inductance_esr = buck_regulator_output_capacitor_max_esr(output_voltage_ripple, min_inductance_ripple)

# RMS-Strom des Ausgangskondensators berechnen
abs_max_inductance_cap_rms = buck_regulator_output_capacitor_rms_current(Vin, Vout, abs_max_inductance, fsw)
max_inductance_cap_rms = buck_regulator_output_capacitor_rms_current(Vin, Vout, max_inductance, fsw)
optimal_inductance_cap_rms = buck_regulator_output_capacitor_rms_current(Vin, Vout, optimal_inductance, fsw)
min_inductance_cap_rms = buck_regulator_output_capacitor_rms_current(Vin, Vout, min_inductance, fsw)

# Ripple-Strom des Ausgangskondensators berechnen
abs_max_inductance_cap_ripple = abs_max_inductance_current.ripple * output_capacitor_ripple_current_safety_factor
max_inductance_cap_ripple = max_inductance_current.ripple * output_capacitor_ripple_current_safety_factor
optimal_inductance_cap_ripple = optimal_inductance_current.ripple * output_capacitor_ripple_current_safety_factor
min_inductance_cap_ripple = min_inductance_current.ripple * output_capacitor_ripple_current_safety_factor

# Ausgabe berechnen

# Sättigungsstrom-Nennwert für die Induktivitäten berechnen
# HINWEIS: Niedriger Sicherheitsfaktor aufgrund der Verwendung des maximalen
# Schalterstroms, der bereits einen Sicherheitsfaktor enthält
# Dieser Sicherheitsfaktor dient hauptsächlich zum Ausgleich einer Induktivitätstoleranz von +-10%
saturation_current_safety_factor = 1.1
abs_max_inductance_saturation_current = max(abs_max_inductance_peak_current, max_switch_current) * saturation_current_safety_factor
max_inductance_saturation_current = max(max_inductance_peak_current, max_switch_current) * saturation_current_safety_factor
optimal_inductance_saturation_current = max(optimal_inductance_peak_current, max_switch_current) * saturation_current_safety_factor
min_inductance_saturation_current = max(min_inductance_peak_current, max_switch_current) * saturation_current_safety_factor

# Catch-Dioden-Leistungsnennwert berechnen
catch_diode_power = buck_regulator_catch_diode_power(Vin, Vout, Ioutmax, fsw)

# Ergebnisse ausgeben
print("Absolute maximum inductance (K=0.1):", format_value(abs_max_inductance, "H"),
    "with Isat >=", format_value(abs_max_inductance_saturation_current, "A"),
    "& Irms >= ", format_value(abs_max_inductance_rms_current, "A"))
print("\tRipple current: ", format_value(abs_max_inductance_ripple, "A"))
print("\tPeak current: ", format_value(abs_max_inductance_peak_current, "A"))
print("\tMin Capacitance: ", format_value(abs_max_inductance_capacitance, "F"), "for ripple voltage", format_value(output_voltage_ripple, "V"))
print("\tMax Capacitor ESR: ", format_value(abs_max_inductance_esr, "Ω"))
print("\tCapacitor RMS current: ", format_value(abs_max_inductance_cap_rms, "A"))
print("\tRecommended capacitor ripple current rating: ", format_value(abs_max_inductance_cap_ripple, "A"))

print("Maximum inductance (K=0.2):", format_value(max_inductance, "H"),
    "with Isat >=", format_value(max_inductance_saturation_current, "A"),
    "& Irms >= ", format_value(max_inductance_rms_current, "A"))
print("\tRipple current: ", format_value(max_inductance_ripple, "A"))
print("\tPeak current: ", format_value(max_inductance_peak_current, "A"))
print("\tMin Capacitance: ", format_value(max_inductance_capacitance, "F"), "for ripple voltage", format_value(output_voltage_ripple, "V"))
print("\tMax Capacitor ESR: ", format_value(max_inductance_esr, "Ω"))
print("\tCapacitor RMS current: ", format_value(max_inductance_cap_rms, "A"))
print("\tRecommended capacitor ripple current rating: ", format_value(max_inductance_cap_ripple, "A"))

print("Optimal inductance (K=0.3):", format_value(optimal_inductance, "H"),
    "with Isat >=", format_value(optimal_inductance_saturation_current, "A"),
    "& Irms >= ", format_value(optimal_inductance_rms_current, "A"))
print("\tRipple current: ", format_value(optimal_inductance_ripple, "A"))
print("\tPeak current: ", format_value(optimal_inductance_peak_current, "A"))
print("\tMin Capacitance: ", format_value(optimal_inductance_capacitance, "F"), "for ripple voltage", format_value(output_voltage_ripple, "V"))
print("\tMax Capacitor ESR: ", format_value(optimal_inductance_esr, "Ω"))
print("\tCapacitor RMS current: ", format_value(optimal_inductance_cap_rms, "A"))
print("\tRecommended capacitor ripple current rating: ", format_value(optimal_inductance_cap_ripple, "A"))

print("Minimum inductance (K=0.4):", format_value(min_inductance, "H"),
    "with Isat >=", format_value(min_inductance_saturation_current, "A"),
    "& Irms >= ", format_value(min_inductance_rms_current, "A"))
print("\tRipple current: ", format_value(min_inductance_ripple, "A"))
print("\tPeak current: ", format_value(min_inductance_peak_current, "A"))
print("\tMin Capacitance: ", format_value(min_inductance_capacitance, "F"), "for ripple voltage", format_value(output_voltage_ripple, "V"))
print("\tMax Capacitor ESR: ", format_value(min_inductance_esr, "Ω"))
print("\tCapacitor RMS current: ", format_value(min_inductance_cap_rms, "A"))
print("\tRecommended capacitor ripple current rating: ", format_value(min_inductance_cap_ripple, "A"))

print()
print("Minimum inductance to avoid subharmonic oscillation: ", format_value(min_inductance_osc, "H"))
print()
print("Catch diode power rating (if any catch diode is required):", format_value(catch_diode_power, "W"))

Absolute maximum inductance (K=0.1): 32.0 µH with Isat >= 9.68 A & Irms >=  5.50 A
        Ripple current:  500 mA
        Peak current:  5.25 A
        Min Capacitance:  138 µF for ripple voltage 240 mV
        Max Capacitor ESR:  480 mΩ
        Capacitor RMS current:  144 mA
        Recommended capacitor ripple current rating:  550 mA
Maximum inductance (K=0.2): 16.0 µH with Isat >= 9.68 A & Irms >=  5.51 A
        Ripple current:  1.00 A
        Peak current:  5.50 A
        Min Capacitance:  69.1 µF for ripple voltage 240 mV
        Max Capacitor ESR:  240 mΩ
        Capacitor RMS current:  289 mA
        Recommended capacitor ripple current rating:  1.10 A
Optimal inductance (K=0.3): 10.7 µH with Isat >= 9.68 A & Irms >=  5.52 A
        Ripple current:  1.50 A
        Peak current:  5.75 A
        Min Capacitance:  46.1 µF for ripple voltage 240 mV
        Max Capacitor ESR:  160 mΩ
        Capacitor RMS current:  433 mA
        Recommended capacitor ripple current rating:  1.65 A
Minimum inductance (K=0.4): 8.00 µH with Isat >= 9.68 A & Irms >=  5.54 A
        Ripple current:  2.00 A
        Peak current:  6.00 A
        Min Capacitance:  34.5 µF for ripple voltage 240 mV
        Max Capacitor ESR:  120 mΩ
        Capacitor RMS current:  577 mA
        Recommended capacitor ripple current rating:  2.20 A

Minimum inductance to avoid subharmonic oscillation:  8.96 µH

Catch diode power rating (if any catch diode is required): 1.93 W

Compute the optimal inducitivity of a buck regulator

This formula is based on the the inductor ripple current fraction [K].

The formula we use is:

L = ((vin - vout) * (vout) / (f * K * Ioutmax)) * (Vout/Vin)

(note that Vout/Vin is an estimation for the duty cycle.)

A good assumption which is shared by most major manufacturers is
to choose the inductor value in between K=0.2 and K=0.4.
Typically, the best inductor value is around K=0.3,
but one depends

It is generally recommended by the more verbose datasheets, to alwas choose
the inductor larger than the value obtained with K=0.1. This is due to the
current mode control scheme which requires a certain level of inductor ripple.

Note that many datasheets also specify minimum inductor values to avoid
subharmonic oscillations. This depends on the part and varies by more than
and order of magnitude and is not handled by the function.

For reference see e.g. TI at https://www.ti.com/lit/ds/symlink/lmr36006.pdf#page=22,
section 9.2.1.2.4: Inductor Selection.