TechOverflow Logo
TechOverflow

Mikrostreifen-Impedanz vs. Breite mit UliEngineering plotten

English Deutsch

Die folgenden Diagramme bieten eine einfache Möglichkeit, die Beziehung zwischen Mikrostreifen-Breite und Impedanz für verschiedene Substrathöhen und Dicken zu visualisieren.

Siehe Prepreg- und Kern-Dicke für verschiedene Standard-Stackups für weitere Informationen zu Standard-PCB-Stackup-Dicken und $\epsilon_r$-Werten.

Microstrip Impedance.svg

Eine andere Art, dieselben Daten zu betrachten, ist das Plotten der dielektrischen Dicke vs. Leiterbahnbreite für voreingestellte Impedanzwerte:

Microstrip Width mm.svg

oder in mil:

Microstrip Width Mil.svg

Basisbeispiel

Dieses Python-Skript zeigt, wie man die Mikrostreifen-Impedanz für einen einzelnen Satz von Parametern mit der UliEngineering-Bibliothek berechnet.

example_microstrip_width_calculation.py
#!/usr/bin/env python3
from UliEngineering.Electronics.Microstrip import microstrip_width
from UliEngineering.EngineerIO import format_value
from UliEngineering.EngineerIO.Length import convert_length_to_unit

# Breite für ein 50 Ω-Mikrostreifen mit String-Argumenten mit Einheiten berechnen
w = microstrip_width("50 Ω", h="150 um", t="35 um", e_r="4.4")
# Ergebnis (Meter) in mil umrechnen und ausgeben
w_mil = convert_length_to_unit(w, "m", "mil")
print(format_value(w_mil, "mil"))

Ausgabe des Beispielskripts

output.txt
10.2 mil

Plot-Quellcode

Dieses Skript wird verwendet, um den oben gezeigten Impedanz-vs-Breite-Plot zu erzeugen.

plot_microstrip_impedance_vs_width.py
#!/usr/bin/env python3
# SPDX-License-Identifier: CC0-1.0
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter, AutoMinorLocator

# UliEngineering-Importe
from UliEngineering.Electronics.Microstrip import microstrip_impedance
from UliEngineering.EngineerIO import format_value
from UliEngineering.EngineerIO.Length import normalize_length

# Konstanten
e_r = 4.4
thicknesses = ["100um", "150um", "200um", "1550um"]
# Kupferdicke (Standard 35um, da nicht spezifiziert, aber für die Berechnung erforderlich)
t_copper = "35um"

# Breitenachse: 1mil bis 10mm linear
w_min = normalize_length("1mil")
w_max = normalize_length("10mm")
# Für eine logarithmische X-Achse benötigen wir logarithmisch verteilte Breiten; verwende np.logspace
widths = np.logspace(np.log10(w_min), np.log10(w_max), 1000)

# Plotten
plt.style.use("ggplot")
fig, ax = plt.subplots(figsize=(10, 12))

# Farben generieren
colors = plt.cm.viridis(np.linspace(0, 1, len(thicknesses)))

for h_str, c in zip(thicknesses, colors):
    # Impedanz für jede Breite berechnen
    # microstrip_impedance verwendet math-Funktionen, unterstützt also keine numpy-Arrays direkt
    zs = [microstrip_impedance(w, h=h_str, t=t_copper, e_r=e_r) for w in widths]
    
    ax.plot(widths, zs, color=c, lw=2, label=f"h={h_str}")

# Eine Legende hinzufügen
legend = ax.legend(loc='upper right', fontsize='small')

ax.set_xscale("log")
ax.set_xlabel("Breite (log-Skala)")
ax.set_ylabel("Impedanz")
ax.set_title(rf"Microstrip Impedance vs Width ($\epsilon_r={e_r}$)")
ax.grid(True, which="both", ls="--")

# Achsen-Formatter mit EngineerIO format_value
ax.xaxis.set_major_formatter(FuncFormatter(lambda x, pos: format_value(x, "m")))
ax.yaxis.set_major_formatter(FuncFormatter(lambda y, pos: format_value(y, "Ω")))

# Nebenticks aktivieren und Nebentick-Beschriftungen auf der Y-Achse hinzufügen
ax.minorticks_on()
# Für lineare Skalierung ist AutoMinorLocator meist gut, oder wir lassen matplotlib es behandeln.
# The template used LogLocator, but we are linear.
ax.yaxis.set_minor_locator(AutoMinorLocator())
ax.yaxis.set_minor_formatter(FuncFormatter(lambda y, pos: format_value(y, "Ω")))

# Nebentick-Beschriftungen formatieren: 30% kleiner und 70% Grau
maj_ylabels = ax.yaxis.get_ticklabels(which='major')
if len(maj_ylabels) > 0:
    base_size = maj_ylabels[0].get_size()
else:
    base_size = plt.rcParams.get('ytick.labelsize', plt.rcParams.get('font.size', 10))
ax.tick_params(axis='y', which='minor', labelsize=base_size * 0.7, labelcolor='0.7', colors='0.7')

# Auch X-Achsen-Nebenticks setzen und mit kleineren gedrehten Beschriftungen formatieren
from matplotlib.ticker import LogLocator
ax.xaxis.set_minor_locator(LogLocator(base=10.0, subs=(2, 3, 4, 5, 6, 7, 8, 9)))
ax.xaxis.set_minor_formatter(FuncFormatter(lambda x, pos: format_value(x, "m")))

maj_xlabels = ax.xaxis.get_ticklabels(which='major')
if len(maj_xlabels) > 0:
    base_x_size = maj_xlabels[0].get_size()
else:
    base_x_size = plt.rcParams.get('xtick.labelsize', plt.rcParams.get('font.size', 10))
ax.tick_params(axis='x', which='minor', labelsize=base_x_size * 0.7, labelcolor='0.7', colors='0.7')

for tl in ax.get_xminorticklabels():
    tl.set_rotation(90)
for tl in ax.get_xmajorticklabels():
    tl.set_rotation(90)

fig.tight_layout()
plt.show()
plt.savefig("Microstrip-Impedance.svg")

Andererseits erzeugt das folgende Skript einen Plot der dielektrischen Dicke vs. voreingestellter Impedanzwerte (der zweite und dritte oben gezeigte Plot, wobei der dritte mit --y-unit mil generiert wird).

plot_microstrip_width_vs_thickness.py
#!/usr/bin/env python3
# SPDX-License-Identifier: CC0-1.0
import argparse
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import FuncFormatter, LogLocator

# UliEngineering-Importe
from UliEngineering.Electronics.Microstrip import microstrip_width
from UliEngineering.EngineerIO import format_value
from UliEngineering.EngineerIO.Length import normalize_length, convert_length_to_unit

# Kommandozeile: Y-Achsen-Einheiten wählen (Standard Meter, oder "mil")
parser = argparse.ArgumentParser(description="Mikrostreifen-Breite vs. dielektrische Dicke plotten")
parser.add_argument("--y-unit", choices=("m", "mil"), default="m",
                    help="Einheiten für die Y-Achse: 'm' für Meter (Standard) oder 'mil' für mils")
args = parser.parse_args()
y_unit = args.y_unit

# Konstanten
e_r = 4.4
impedances = [50, 75, 100]
# Kupferdicke
t_copper = "35um"

# Dickenachse: 70um bis 2.0mm (logarithmische Abtastung, sodass Werte auf einer log-X-Achse schön verteilt sind)
h_min = normalize_length("70um")
h_max = normalize_length("2mm")
thicknesses = np.logspace(np.log10(h_min), np.log10(h_max), num=1000)

# Plotten
plt.style.use("ggplot")
fig, ax = plt.subplots(figsize=(10, 8))

# Farben mit viridis für schönere, wahrnehmungsgerechte Farben generieren
colors = plt.cm.viridis(np.linspace(0, 1, len(impedances)))

# Breitenverläufe berechnen und für die Bestimmung der Y-Grenzen sammeln
all_ws = []
for z0, c in zip(impedances, colors):
    ws = [microstrip_width(Z0=z0, h=h, t=t_copper, e_r=e_r) for h in thicknesses]
    ax.plot(thicknesses, ws, color=c, lw=2, label=f"Z0={z0} Ω")
    all_ws.append(np.array(ws))

# Eine Legende hinzufügen
legend = ax.legend(loc='upper left', fontsize='medium')

ax.set_xlabel("Dielektrische Dicke")
ax.set_ylabel(f"Trace Width ({'m' if y_unit == 'm' else 'mil'})")
ax.set_title(rf"Microstrip Width vs Dielectric Thickness ($\epsilon_r={e_r}$, $t_{{Cu}}={t_copper}$)")
ax.grid(True, which="both", ls="--")

# Logarithmische Skalierung auf beiden Achsen
ax.set_xscale("log")
ax.set_yscale("log")

# X-Grenzen von 70 µm bis 2.0 mm genau festlegen
ax.set_xlim(h_min, h_max)

# Major- und Minor-Locators für logarithmische Achsen konfigurieren
major_x_locator = LogLocator(base=10.0)
minor_x_locator = LogLocator(base=10.0, subs=(2, 3, 4, 5, 6, 7, 8, 9))
major_y_locator = LogLocator(base=10.0)
minor_y_locator = LogLocator(base=10.0, subs=(2, 3, 4, 5, 6, 7, 8, 9))
ax.xaxis.set_major_locator(major_x_locator)
ax.xaxis.set_minor_locator(minor_x_locator)
ax.yaxis.set_major_locator(major_y_locator)
ax.yaxis.set_minor_locator(minor_y_locator)

# Achsen-Formatter mit EngineerIO format_value
ax.xaxis.set_major_formatter(FuncFormatter(lambda x, pos: format_value(x, "m")))

# Y-Achsen-Formatter hängt von der angeforderten Einheit ab.
if y_unit == "m":
    ax.yaxis.set_major_formatter(FuncFormatter(lambda y, pos: format_value(y, "m")))
    ax.yaxis.set_minor_formatter(FuncFormatter(lambda y, pos: format_value(y, "m")))
else:
    # Werte in mil ohne SI-Präfixe mit der Hilfsfunktion formatieren
    def format_mil_no_prefix(y, pos):
        mils = convert_length_to_unit(y, "m", "mil")
        if mils >= 100:
            s = f"{int(round(mils))} mil"
        elif mils >= 10:
            s = f"{mils:.1f} mil"
        elif mils >= 1:
            s = f"{mils:.2f} mil"
        else:
            s = f"{mils:.3f} mil"
        return s

    ax.yaxis.set_major_formatter(FuncFormatter(format_mil_no_prefix))
    ax.yaxis.set_minor_formatter(FuncFormatter(format_mil_no_prefix))

# Nebenticks aktivieren
ax.minorticks_on()
ax.xaxis.set_minor_formatter(FuncFormatter(lambda x, pos: format_value(x, "m")))

# X-Ticks berechnen und setzen, eingeschränkt auf den angeforderten X-Bereich
major_locs = major_x_locator.tick_values(h_min, h_max)
minor_locs = minor_x_locator.tick_values(h_min, h_max)
major_locs = np.array([m for m in major_locs if m >= h_min and m <= h_max])
minor_locs = np.array([m for m in minor_locs if m >= h_min and m <= h_max])

# Speziellen Nebentick bei X = 1.55 mm hinzufügen
special_tick = normalize_length("1.55mm")
if special_tick not in minor_locs:
    minor_locs = np.sort(np.concatenate((minor_locs, [special_tick])))

# Ticks explizit setzen
ax.set_xticks(major_locs, minor=False)
ax.set_xticks(minor_locs, minor=True)

# Auch eine dezente vertikale Hilfslinie bei 1.55 mm zeichnen, um den speziellen Punkt hervorzuheben
ax.axvline(special_tick, color='0.5', linestyle=':', linewidth=1)

# Y-Bereich aus Daten berechnen und passende Ticks im mil-Modus setzen
if len(all_ws) > 0:
    y_all = np.concatenate(all_ws)
    y_all = y_all[y_all > 0]
    if len(y_all) > 0:
        y_min = np.min(y_all)
        y_max = np.max(y_all)
        # padding
        y_pad = (np.log10(y_max) - np.log10(y_min)) * 0.05 if y_max > y_min else 0.1
        ax.set_ylim(10 ** (np.log10(y_min) - y_pad), 10 ** (np.log10(y_max) + y_pad))

        if y_unit == 'mil':
            yl, yu = ax.get_ylim()
            yl_mil = convert_length_to_unit(yl, 'm', 'mil')
            yu_mil = convert_length_to_unit(yu, 'm', 'mil')
            # choose major decades in mils (10, 100, 1000, ...)
            dmin = int(np.floor(np.log10(max(yl_mil, 1e-12))))
            dmax = int(np.ceil(np.log10(max(yu_mil, 1e-12))))
            # Ensure we include 1 mil (10^0) as a major tick when possible
            dstart = max(0, dmin)
            majors_mil = [10 ** d for d in range(dstart, dmax + 1)]
            majors_m = [convert_length_to_unit(m, 'mil', 'm') for m in majors_mil]
            minors_m = []
            for d in range(dstart, dmax + 1):
                for s in (2, 3, 4, 5, 6, 7, 8, 9):
                    v_mil = s * (10 ** d)
                    minors_m.append(convert_length_to_unit(v_mil, 'mil', 'm'))
            majors_m = np.array([m for m in majors_m if m >= yl and m <= yu])
            minors_m = np.array([m for m in minors_m if m >= yl and m <= yu])
            ax.set_yticks(majors_m, minor=False)
            ax.set_yticks(minors_m, minor=True)

# Beschriftungen bei Bedarf drehen
for tl in ax.get_xminorticklabels():
    tl.set_rotation(90)
for tl in ax.get_xmajorticklabels():
    tl.set_rotation(90)

# Nebentick-Beschriftungen formatieren: 30% kleiner und 70% Grau (beide Achsen)
maj_ylabels = ax.yaxis.get_ticklabels(which='major')
if len(maj_ylabels) > 0:
    base_y_size = maj_ylabels[0].get_size()
else:
    base_y_size = plt.rcParams.get('ytick.labelsize', plt.rcParams.get('font.size', 10))
maj_xlabels = ax.xaxis.get_ticklabels(which='major')
if len(maj_xlabels) > 0:
    base_x_size = maj_xlabels[0].get_size()
else:
    base_x_size = plt.rcParams.get('xtick.labelsize', plt.rcParams.get('font.size', 10))
ax.tick_params(axis='y', which='minor', labelsize=base_y_size * 0.7, labelcolor='0.7', colors='0.7')
ax.tick_params(axis='x', which='minor', labelsize=base_x_size * 0.7, labelcolor='0.7', colors='0.7')

fig.tight_layout()
plt.savefig("Microstrip-Width.svg", dpi=300, bbox_inches='tight')
# Nur interaktiv anzeigen, wenn nicht in headless CI
try:
    plt.show()
except Exception:
    pass
Check out similar posts by category: Electronics, RF