lokomotive/code/auslegung_lokomotive_hängebahn.ipynb

Auslegungsrechnung: Lokomotive für Hängeförderbahn

Diese Rechnung untersucht, wie schwer eine Lokomotive sein muss, um über Reibschluss eine Zugkraft von 100 N aufzubringen. Zusätzlich wird das nötige Antriebsmoment pro Rolle berechnet. Im Anschluss kann aus der Fahrgeschwindigkeit die Drehzahl der Rollen sowie die benötigte Antriebsleistung ermittelt werden. Erste Annahmen für Batteriekapazität werden getroffen.

Annahmen

• Zugkraftbedarf (Anfahren): 100 N

• Anfahrbeschleuniugung: 0.1-0.2 m/s^2

• Zugkraftbedarf (Konstantfahrt): 10 N

• Reibwert Gummi auf Aluminium: variabel, realistisch: 0.3–0.6

• Rollendurchmesser: z. B. 80 mm

• Anzahl angetriebener Rollen: z. B. 2

Mathematische Grundlagen

Die Lokomotive bewegt sich auf einem Aluminiumprofil mit zwei 45° geneigten Flanken. Die Zugkraft wird über Reibung zwischen den angetriebenen Gummirädern und dem Profil erzeugt. Die folgenden Gleichungen beschreiben die physikalische Auslegung.

---

1. Gewicht der Lokomotive

Aus der Gleichgewichtsbedingung bei Reibung auf 2× 45°-Flanken:

F_{\text{N,gesamt}} = 2 \cdot \left( \frac{G}{2} \cdot \cos(45^\circ) \right) = \frac{G}{\sqrt{2}}

Maximale Reibkraft:

F_{\text{Reib}} = \mu \cdot F_{\text{N,gesamt}} = \mu \cdot \frac{G}{\sqrt{2}}

Gleichsetzen mit Zugkraft:

F_{\text{Zug}} = \mu \cdot \frac{G}{\sqrt{2}} \Rightarrow G = \frac{F_{\text{Zug}} \cdot \sqrt{2}}{\mu}

Masse der Lokomotive:

m = \frac{G}{g} = \frac{F_{\text{Zug}} \cdot \sqrt{2}}{\mu \cdot g}

---

2. Drehmoment an den Antriebsrollen

Bei gleichmäßiger Verteilung auf n_{\text{Rollen}} Rollen mit Durchmesser d:

F_{\text{Rolle}} = \frac{F_{\text{Zug}}}{n_{\text{Rollen}}}

M = F_{\text{Rolle}} \cdot \frac{d}{2}

Gesamtmoment:

M_{\text{gesamt}} = n_{\text{Rollen}} \cdot M = F_{\text{Zug}} \cdot \frac{d}{2}

---

3. Drehzahl der Rollen

Bei Zielgeschwindigkeit v und Rollendurchmesser d:

n = \frac{v}{\pi \cdot d} \cdot 60

---

4. Leistung am Antrieb

Die mechanische Leistung berechnet sich zu:

P = M_{\text{gesamt}} \cdot \omega = M_{\text{gesamt}} \cdot \left( \frac{2\pi \cdot n}{60} \right)

---

5. Batteriekapazität (theoretisch)

Bei Betriebsdauer t (in Stunden) und Spannung U:

Q_{\text{Wh}} = P \cdot t

Q_{\text{Ah}} = \frac{Q_{\text{Wh}}}{U}

In [189]:

import numpy as np
import matplotlib.pyplot as plt


# Konstanten
g = 9.81  # Erdbeschleunigung in m/s²

# Eingabeparameter
f_zug_anfaren = 100  # Zugkraftbedarf max. in N
f_zug_konstant = 10  # Zugkraftbedarf konst. in N
fahrgeschwindigkeit_ms = 1.3  # Fahrgeschwindigkeit in m/s
mu_min = 0.3  # minimaler Reibwert
mu_max = 0.7  # maximaler Reibwert
rollendurchmesser_mm = 50  # Rollendurchmesser in mm
anzahl_rollen = 2  # Anzahl angetriebener Rollen


# Zusätzliche Parameter für Plots
betriebszeit_min = 1 # Minimale Betriebszeit in Stunden für Batterieplot
betriebszeit_max = 8 # Maximale Betriebszeit in Stunden für Batterieplot
betriebsspannung_v = 24 # Angenommene Betriebsspannung in Volt

def berechne_lokgewicht(f_zug, mu_eff):
    """Berechnet das notwendige Lokgewicht für eine gegebene effektive Reibung"""
    G = (f_zug * np.sqrt(2)) / mu_eff  # Gewichtskraft in N, sqrt(2) aufgrund der 45° geneigten Lauffläche der Rollen
    m = G / g  # Masse in kg
    return m

def berechne_drehmoment(f_zug, rollendurchmesser_mm, anzahl_rollen):
    """Berechnet das Drehmoment pro Rolle in Nm"""
    r = rollendurchmesser_mm / 2000  # Radius in Meter (Durchmesser / 2 / 1000)
    f_pro_rolle = f_zug / anzahl_rollen
    M_pro_rolle = f_pro_rolle * r
    return M_pro_rolle

def berechne_drehzahl(fahrgeschwindigkeit_ms, rollendurchmesser_mm):
    """Berechnet die Drehzahl der Rollen in Umdrehungen pro Minute (RPM)."""
    rollenradius_m = (rollendurchmesser_mm / 2) / 1000  # Radius in Metern
    drehzahl_rad_s = fahrgeschwindigkeit_ms / rollenradius_m
    drehzahl_rpm = drehzahl_rad_s * (60 / (2 * np.pi))
    return drehzahl_rpm


def berechne_leistung(drehmoment_pro_rolle, drehzahl_rpm, anzahl_rollen):
    """Berechnet die benötigte Antriebsleistung."""
    drehzahl_rad_s = drehzahl_rpm * (2 * np.pi / 60)
    gesamt_drehmoment = drehmoment_pro_rolle * anzahl_rollen
    leistung_watt = gesamt_drehmoment * drehzahl_rad_s
    return leistung_watt

def berechne_batteriekapazitaet(leistung_watt, betriebszeit_h, betriebsspannung_v, sicherheitsfaktor=1.2):
    """Berechnet die benötigte Batteriekapazität in Amperestunden (Ah)."""
    energie_wh = leistung_watt * betriebszeit_h
    kapazitaet_ah = (energie_wh / betriebsspannung_v) * sicherheitsfaktor
    return kapazitaet_ah

Plot: Lokgewicht über Reibwert

Dieser Plot zeigt, wie stark das notwendige Lokgewicht vom angenommenen Reibwert abhängt. Reibwerte im oberen Bereich sollten angestrebt werden.

In [190]:

# Beispielwerte
f_zug_anfaren = 100  # N
mu_werte = np.linspace(mu_min, mu_max, 50)
lokgewichte = [berechne_lokgewicht(f_zug_anfaren, mu) for mu in mu_werte]

# Plot
plt.figure(figsize=(5, 3))
plt.plot(mu_werte, lokgewichte, label='Benötigtes Lokgewicht', color='blue')
plt.xlabel("Effektiver Reibwert (μ)")
plt.ylabel("Erforderliches Lokgewicht (kg)")
plt.title("Einfluss des Reibwerts auf das Lokgewicht für 100 N Zugkraft")
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()

Beispielrechnung mit festen Parametern

In [191]:

# Einheitlicher Reibwert
mu = 0.5

# Beschleunigungsbedarf
a = 0.1 # m/s^2

# Anteil der Betriebsmodi
anteil_anfahren = 0.05
anteil_konstant = 0.95

# Berechnungen
gewicht_anfahren = berechne_lokgewicht(f_zug_anfaren, mu)

# Wir verwenden dieselbe Drehzahl für beide Fälle
drehzahl_rpm = berechne_drehzahl(fahrgeschwindigkeit_ms, rollendurchmesser_mm)

# Drehmomente und Leistungen
drehmoment_anfahren = berechne_drehmoment(f_zug_anfaren, rollendurchmesser_mm, anzahl_rollen)
leistung_anfahren = berechne_leistung(drehmoment_anfahren, drehzahl_rpm, anzahl_rollen)

drehmoment_konstant = berechne_drehmoment(f_zug_konstant, rollendurchmesser_mm, anzahl_rollen)
leistung_konstant = berechne_leistung(drehmoment_konstant, drehzahl_rpm, anzahl_rollen)

# Gemittelte Leistung
leistung_mittel = anteil_anfahren * leistung_anfahren + anteil_konstant * leistung_konstant

# Energieverbrauch pro Meter (Wh/m)
energieverbrauch_wh_pro_m = leistung_mittel / fahrgeschwindigkeit_ms / 3600  # (W / m/s) * (1/3600) = Wh/m

# Batteriebedarf für typische Betriebszeiten
betriebszeiten = np.linspace(betriebszeit_min, betriebszeit_max, 100)
kapazitaet_ah_mittel = [berechne_batteriekapazitaet(leistung_mittel, t, betriebsspannung_v) for t in betriebszeiten]

# Ausgabe
print("=== Typischer Mischbetrieb (95 % Konstantfahrt, 5 % Anfahren) ===")
print(f"Mittlere Antriebsleistung: {leistung_mittel:.2f} W")
print(f"Benötigtes Drehmoment im Anfahren: {drehmoment_anfahren:.2f} Nm")
print(f"Benötigtes Drehmoment in Konstanntfahrt: {drehmoment_konstant:.2f} Nm")
print(f"Energieverbrauch pro Meter: {energieverbrauch_wh_pro_m:.3f} Wh/m")
print(f"Benötigte Masse (aus Spitzenlast): {gewicht_anfahren:.2f} kg")
print(f"Drehzahl der Rollen: {drehzahl_rpm:.1f} RPM")

=== Typischer Mischbetrieb (95 % Konstantfahrt, 5 % Anfahren) ===
Mittlere Antriebsleistung: 18.85 W
Benötigtes Drehmoment im Anfahren: 1.25 Nm
Benötigtes Drehmoment in Konstanntfahrt: 0.12 Nm
Energieverbrauch pro Meter: 0.004 Wh/m
Benötigte Masse (aus Spitzenlast): 28.83 kg
Drehzahl der Rollen: 496.6 RPM

In [192]:

import numpy as np
import matplotlib.pyplot as plt

# Parameter
m = gewicht_anfahren  # Masse in kg
a = 0.1  # Beschleunigung in m/s²


# Abgeleitete Größen
t_beschleunigung = fahrgeschwindigkeit_ms / a  # Zeit bis Zielgeschwindigkeit erreicht ist
F_beschleunigung = m * a  # Trägheitskraft in N

# Zeitvektor
t = np.linspace(0, t_beschleunigung + 2, 1000)

# Geschwindigkeit über die Zeit
v = np.where(t <= t_beschleunigung, a * t, fahrgeschwindigkeit_ms)

# Momentane Leistung
P_momentan = np.where(
    t <= t_beschleunigung,
    (F_beschleunigung + f_zug_konstant) * v,
    f_zug_konstant * fahrgeschwindigkeit_ms
)

# Plot
plt.figure(figsize=(10, 5))
plt.plot(t, P_momentan, label="Momentanleistung [W]", color="crimson")
plt.axvline(t_beschleunigung, linestyle="--", color="gray", label="Ende Beschleunigung")
plt.axhline(f_zug_konstant * fahrgeschwindigkeit_ms, linestyle=":", color="green", label="Leistung bei Konstantfahrt")
plt.xlabel("Zeit [s]")
plt.ylabel("Leistung [W]")
plt.title("Momentanleistung während Anfahren und Konstantfahrt")
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()