102 KiB
102 KiB
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()