commit 1dc9cae8f8505d5aeae0685f27caca8d69b8e0fa Author: lertlmaier Date: Wed Jul 30 10:03:42 2025 +0200 Dateien initial dazu diff --git a/cad/Einzelteile/826004211.asm b/cad/Einzelteile/826004211.asm new file mode 100644 index 0000000..2ca65f7 Binary files /dev/null and b/cad/Einzelteile/826004211.asm differ diff --git a/cad/Einzelteile/826004211.cfg b/cad/Einzelteile/826004211.cfg new file mode 100644 index 0000000..a58b452 Binary files /dev/null and b/cad/Einzelteile/826004211.cfg differ diff --git a/cad/Einzelteile/826006003.par b/cad/Einzelteile/826006003.par new file mode 100644 index 0000000..fead896 Binary files /dev/null and b/cad/Einzelteile/826006003.par differ diff --git a/cad/Einzelteile/826006022.par b/cad/Einzelteile/826006022.par new file mode 100644 index 0000000..59809bf Binary files /dev/null and b/cad/Einzelteile/826006022.par differ diff --git a/cad/Einzelteile/826006216.par b/cad/Einzelteile/826006216.par new file mode 100644 index 0000000..24899d6 Binary files /dev/null and b/cad/Einzelteile/826006216.par differ diff --git a/cad/Einzelteile/826006220.par b/cad/Einzelteile/826006220.par new file mode 100644 index 0000000..7ff4b76 Binary files /dev/null and b/cad/Einzelteile/826006220.par differ diff --git a/cad/Einzelteile/Halter.par b/cad/Einzelteile/Halter.par new file mode 100644 index 0000000..f13c14a Binary files /dev/null and b/cad/Einzelteile/Halter.par differ diff --git a/cad/Einzelteile/Motor_Mock.par b/cad/Einzelteile/Motor_Mock.par new file mode 100644 index 0000000..0503618 Binary files /dev/null and b/cad/Einzelteile/Motor_Mock.par differ diff --git a/cad/Einzelteile/Motorhalter.par b/cad/Einzelteile/Motorhalter.par new file mode 100644 index 0000000..f79f727 Binary files /dev/null and b/cad/Einzelteile/Motorhalter.par differ diff --git a/cad/Einzelteile/Rolle.par b/cad/Einzelteile/Rolle.par new file mode 100644 index 0000000..e77ac37 Binary files /dev/null and b/cad/Einzelteile/Rolle.par differ diff --git a/cad/Einzelteile/ZB_Rolle_Motor.asm b/cad/Einzelteile/ZB_Rolle_Motor.asm new file mode 100644 index 0000000..2cde940 Binary files /dev/null and b/cad/Einzelteile/ZB_Rolle_Motor.asm differ diff --git a/cad/Einzelteile/ZB_Rolle_Motor.cfg b/cad/Einzelteile/ZB_Rolle_Motor.cfg new file mode 100644 index 0000000..14f48ca Binary files /dev/null and b/cad/Einzelteile/ZB_Rolle_Motor.cfg differ diff --git a/cad/Einzelteile/ZB_Wagen.asm b/cad/Einzelteile/ZB_Wagen.asm new file mode 100644 index 0000000..ff06eb1 Binary files /dev/null and b/cad/Einzelteile/ZB_Wagen.asm differ diff --git a/cad/Einzelteile/ZB_Wagen.cfg b/cad/Einzelteile/ZB_Wagen.cfg new file mode 100644 index 0000000..5fbef7d Binary files /dev/null and b/cad/Einzelteile/ZB_Wagen.cfg differ diff --git a/cad/Schiene.par b/cad/Schiene.par new file mode 100644 index 0000000..462de85 Binary files /dev/null and b/cad/Schiene.par differ diff --git a/cad/UBG_Weiche.asm b/cad/UBG_Weiche.asm new file mode 100644 index 0000000..3385365 Binary files /dev/null and b/cad/UBG_Weiche.asm differ diff --git a/cad/ZB_Weiche_ges.asm b/cad/ZB_Weiche_ges.asm new file mode 100644 index 0000000..ebe9a2f Binary files /dev/null and b/cad/ZB_Weiche_ges.asm differ diff --git a/cad/ZB_Weiche_ges.cfg b/cad/ZB_Weiche_ges.cfg new file mode 100644 index 0000000..8d2d5e3 Binary files /dev/null and b/cad/ZB_Weiche_ges.cfg differ diff --git a/cad/readme.txt b/cad/readme.txt new file mode 100644 index 0000000..58dacd9 --- /dev/null +++ b/cad/readme.txt @@ -0,0 +1,6 @@ +UBG Weiche ist nur Weiche als bewegliche .asm + +ZB_weiche_ges ist gesamtbaugruppe (Weiche, Sciene + Fahrzeug) + +Einzelteile beinhaltet die einzelnen Bauteile des Fahzeugs + diff --git a/cad/stössel.asm b/cad/stössel.asm new file mode 100644 index 0000000..cec041b Binary files /dev/null and b/cad/stössel.asm differ diff --git a/code/auslegung_lokomotive_hängebahn.ipynb b/code/auslegung_lokomotive_hängebahn.ipynb new file mode 100644 index 0000000..283681c --- /dev/null +++ b/code/auslegung_lokomotive_hängebahn.ipynb @@ -0,0 +1,368 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auslegungsrechnung: Lokomotive für Hängeförderbahn\n", + "\n", + "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.\n", + "\n", + "## Annahmen\n", + "- Zugkraftbedarf (Anfahren): **100 N**\n", + "- Anfahrbeschleuniugung: **0.1-0.2 m/s^2**\n", + "- Zugkraftbedarf (Konstantfahrt): **10 N**\n", + "\n", + "- Reibwert Gummi auf Aluminium: variabel, realistisch: **0.3–0.6**\n", + "- Rollendurchmesser: z. B. **80 mm**\n", + "- Anzahl angetriebener Rollen: z. B. **2**\n" + ] + }, + { + "cell_type": "markdown", + "id": "fe11045c", + "metadata": {}, + "source": [ + "## Mathematische Grundlagen\n", + "\n", + "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.\n", + "\n", + "---\n", + "\n", + "### 1. Gewicht der Lokomotive\n", + "\n", + "Aus der Gleichgewichtsbedingung bei Reibung auf 2× 45°-Flanken:\n", + "\n", + "$$\n", + "F_{\\text{N,gesamt}} = 2 \\cdot \\left( \\frac{G}{2} \\cdot \\cos(45^\\circ) \\right) = \\frac{G}{\\sqrt{2}}\n", + "$$\n", + "\n", + "Maximale Reibkraft:\n", + "\n", + "$$\n", + "F_{\\text{Reib}} = \\mu \\cdot F_{\\text{N,gesamt}} = \\mu \\cdot \\frac{G}{\\sqrt{2}}\n", + "$$\n", + "\n", + "Gleichsetzen mit Zugkraft:\n", + "\n", + "$$\n", + "F_{\\text{Zug}} = \\mu \\cdot \\frac{G}{\\sqrt{2}} \\Rightarrow G = \\frac{F_{\\text{Zug}} \\cdot \\sqrt{2}}{\\mu}\n", + "$$\n", + "\n", + "Masse der Lokomotive:\n", + "\n", + "$$\n", + "m = \\frac{G}{g} = \\frac{F_{\\text{Zug}} \\cdot \\sqrt{2}}{\\mu \\cdot g}\n", + "$$\n", + "\n", + "---\n", + "\n", + "### 2. Drehmoment an den Antriebsrollen\n", + "\n", + "Bei gleichmäßiger Verteilung auf $n_{\\text{Rollen}}$ Rollen mit Durchmesser $d$:\n", + "\n", + "$$\n", + "F_{\\text{Rolle}} = \\frac{F_{\\text{Zug}}}{n_{\\text{Rollen}}}\n", + "$$\n", + "\n", + "$$\n", + "M = F_{\\text{Rolle}} \\cdot \\frac{d}{2}\n", + "$$\n", + "\n", + "Gesamtmoment:\n", + "\n", + "$$\n", + "M_{\\text{gesamt}} = n_{\\text{Rollen}} \\cdot M = F_{\\text{Zug}} \\cdot \\frac{d}{2}\n", + "$$\n", + "\n", + "---\n", + "\n", + "### 3. Drehzahl der Rollen\n", + "\n", + "Bei Zielgeschwindigkeit $v$ und Rollendurchmesser $d$:\n", + "\n", + "$$\n", + "n = \\frac{v}{\\pi \\cdot d} \\cdot 60\n", + "$$\n", + "\n", + "---\n", + "\n", + "### 4. Leistung am Antrieb\n", + "\n", + "Die mechanische Leistung berechnet sich zu:\n", + "\n", + "$$\n", + "P = M_{\\text{gesamt}} \\cdot \\omega = M_{\\text{gesamt}} \\cdot \\left( \\frac{2\\pi \\cdot n}{60} \\right)\n", + "$$\n", + "\n", + "---\n", + "\n", + "### 5. Batteriekapazität (theoretisch)\n", + "\n", + "Bei Betriebsdauer $t$ (in Stunden) und Spannung $U$:\n", + "\n", + "$$\n", + "Q_{\\text{Wh}} = P \\cdot t\n", + "$$\n", + "\n", + "$$\n", + "Q_{\\text{Ah}} = \\frac{Q_{\\text{Wh}}}{U}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Konstanten\n", + "g = 9.81 # Erdbeschleunigung in m/s²\n", + "\n", + "# Eingabeparameter\n", + "f_zug_anfaren = 100 # Zugkraftbedarf max. in N\n", + "f_zug_konstant = 10 # Zugkraftbedarf konst. in N\n", + "fahrgeschwindigkeit_ms = 1.3 # Fahrgeschwindigkeit in m/s\n", + "mu_min = 0.3 # minimaler Reibwert\n", + "mu_max = 0.7 # maximaler Reibwert\n", + "rollendurchmesser_mm = 50 # Rollendurchmesser in mm\n", + "anzahl_rollen = 2 # Anzahl angetriebener Rollen\n", + "\n", + "\n", + "# Zusätzliche Parameter für Plots\n", + "betriebszeit_min = 1 # Minimale Betriebszeit in Stunden für Batterieplot\n", + "betriebszeit_max = 8 # Maximale Betriebszeit in Stunden für Batterieplot\n", + "betriebsspannung_v = 24 # Angenommene Betriebsspannung in Volt\n", + "\n", + "def berechne_lokgewicht(f_zug, mu_eff):\n", + " \"\"\"Berechnet das notwendige Lokgewicht für eine gegebene effektive Reibung\"\"\"\n", + " G = (f_zug * np.sqrt(2)) / mu_eff # Gewichtskraft in N, sqrt(2) aufgrund der 45° geneigten Lauffläche der Rollen\n", + " m = G / g # Masse in kg\n", + " return m\n", + "\n", + "def berechne_drehmoment(f_zug, rollendurchmesser_mm, anzahl_rollen):\n", + " \"\"\"Berechnet das Drehmoment pro Rolle in Nm\"\"\"\n", + " r = rollendurchmesser_mm / 2000 # Radius in Meter (Durchmesser / 2 / 1000)\n", + " f_pro_rolle = f_zug / anzahl_rollen\n", + " M_pro_rolle = f_pro_rolle * r\n", + " return M_pro_rolle\n", + "\n", + "def berechne_drehzahl(fahrgeschwindigkeit_ms, rollendurchmesser_mm):\n", + " \"\"\"Berechnet die Drehzahl der Rollen in Umdrehungen pro Minute (RPM).\"\"\"\n", + " rollenradius_m = (rollendurchmesser_mm / 2) / 1000 # Radius in Metern\n", + " drehzahl_rad_s = fahrgeschwindigkeit_ms / rollenradius_m\n", + " drehzahl_rpm = drehzahl_rad_s * (60 / (2 * np.pi))\n", + " return drehzahl_rpm\n", + "\n", + "\n", + "def berechne_leistung(drehmoment_pro_rolle, drehzahl_rpm, anzahl_rollen):\n", + " \"\"\"Berechnet die benötigte Antriebsleistung.\"\"\"\n", + " drehzahl_rad_s = drehzahl_rpm * (2 * np.pi / 60)\n", + " gesamt_drehmoment = drehmoment_pro_rolle * anzahl_rollen\n", + " leistung_watt = gesamt_drehmoment * drehzahl_rad_s\n", + " return leistung_watt\n", + "\n", + "def berechne_batteriekapazitaet(leistung_watt, betriebszeit_h, betriebsspannung_v, sicherheitsfaktor=1.2):\n", + " \"\"\"Berechnet die benötigte Batteriekapazität in Amperestunden (Ah).\"\"\"\n", + " energie_wh = leistung_watt * betriebszeit_h\n", + " kapazitaet_ah = (energie_wh / betriebsspannung_v) * sicherheitsfaktor\n", + " return kapazitaet_ah\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot: Lokgewicht über Reibwert\n", + "Dieser Plot zeigt, wie stark das notwendige Lokgewicht vom angenommenen Reibwert abhängt. Reibwerte im oberen Bereich sollten angestrebt werden." + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Beispielwerte\n", + "f_zug_anfaren = 100 # N\n", + "mu_werte = np.linspace(mu_min, mu_max, 50)\n", + "lokgewichte = [berechne_lokgewicht(f_zug_anfaren, mu) for mu in mu_werte]\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(5, 3))\n", + "plt.plot(mu_werte, lokgewichte, label='Benötigtes Lokgewicht', color='blue')\n", + "plt.xlabel(\"Effektiver Reibwert (μ)\")\n", + "plt.ylabel(\"Erforderliches Lokgewicht (kg)\")\n", + "plt.title(\"Einfluss des Reibwerts auf das Lokgewicht für 100 N Zugkraft\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Beispielrechnung mit festen Parametern" + ] + }, + { + "cell_type": "code", + "execution_count": 191, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Typischer Mischbetrieb (95 % Konstantfahrt, 5 % Anfahren) ===\n", + "Mittlere Antriebsleistung: 18.85 W\n", + "Benötigtes Drehmoment im Anfahren: 1.25 Nm\n", + "Benötigtes Drehmoment in Konstanntfahrt: 0.12 Nm\n", + "Energieverbrauch pro Meter: 0.004 Wh/m\n", + "Benötigte Masse (aus Spitzenlast): 28.83 kg\n", + "Drehzahl der Rollen: 496.6 RPM\n" + ] + } + ], + "source": [ + "# Einheitlicher Reibwert\n", + "mu = 0.5\n", + "\n", + "# Beschleunigungsbedarf\n", + "a = 0.1 # m/s^2\n", + "\n", + "# Anteil der Betriebsmodi\n", + "anteil_anfahren = 0.05\n", + "anteil_konstant = 0.95\n", + "\n", + "# Berechnungen\n", + "gewicht_anfahren = berechne_lokgewicht(f_zug_anfaren, mu)\n", + "\n", + "# Wir verwenden dieselbe Drehzahl für beide Fälle\n", + "drehzahl_rpm = berechne_drehzahl(fahrgeschwindigkeit_ms, rollendurchmesser_mm)\n", + "\n", + "# Drehmomente und Leistungen\n", + "drehmoment_anfahren = berechne_drehmoment(f_zug_anfaren, rollendurchmesser_mm, anzahl_rollen)\n", + "leistung_anfahren = berechne_leistung(drehmoment_anfahren, drehzahl_rpm, anzahl_rollen)\n", + "\n", + "drehmoment_konstant = berechne_drehmoment(f_zug_konstant, rollendurchmesser_mm, anzahl_rollen)\n", + "leistung_konstant = berechne_leistung(drehmoment_konstant, drehzahl_rpm, anzahl_rollen)\n", + "\n", + "# Gemittelte Leistung\n", + "leistung_mittel = anteil_anfahren * leistung_anfahren + anteil_konstant * leistung_konstant\n", + "\n", + "# Energieverbrauch pro Meter (Wh/m)\n", + "energieverbrauch_wh_pro_m = leistung_mittel / fahrgeschwindigkeit_ms / 3600 # (W / m/s) * (1/3600) = Wh/m\n", + "\n", + "# Batteriebedarf für typische Betriebszeiten\n", + "betriebszeiten = np.linspace(betriebszeit_min, betriebszeit_max, 100)\n", + "kapazitaet_ah_mittel = [berechne_batteriekapazitaet(leistung_mittel, t, betriebsspannung_v) for t in betriebszeiten]\n", + "\n", + "# Ausgabe\n", + "print(\"=== Typischer Mischbetrieb (95 % Konstantfahrt, 5 % Anfahren) ===\")\n", + "print(f\"Mittlere Antriebsleistung: {leistung_mittel:.2f} W\")\n", + "print(f\"Benötigtes Drehmoment im Anfahren: {drehmoment_anfahren:.2f} Nm\")\n", + "print(f\"Benötigtes Drehmoment in Konstanntfahrt: {drehmoment_konstant:.2f} Nm\")\n", + "print(f\"Energieverbrauch pro Meter: {energieverbrauch_wh_pro_m:.3f} Wh/m\")\n", + "print(f\"Benötigte Masse (aus Spitzenlast): {gewicht_anfahren:.2f} kg\")\n", + "print(f\"Drehzahl der Rollen: {drehzahl_rpm:.1f} RPM\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 192, + "id": "d894f650", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Parameter\n", + "m = gewicht_anfahren # Masse in kg\n", + "a = 0.1 # Beschleunigung in m/s²\n", + "\n", + "\n", + "# Abgeleitete Größen\n", + "t_beschleunigung = fahrgeschwindigkeit_ms / a # Zeit bis Zielgeschwindigkeit erreicht ist\n", + "F_beschleunigung = m * a # Trägheitskraft in N\n", + "\n", + "# Zeitvektor\n", + "t = np.linspace(0, t_beschleunigung + 2, 1000)\n", + "\n", + "# Geschwindigkeit über die Zeit\n", + "v = np.where(t <= t_beschleunigung, a * t, fahrgeschwindigkeit_ms)\n", + "\n", + "# Momentane Leistung\n", + "P_momentan = np.where(\n", + " t <= t_beschleunigung,\n", + " (F_beschleunigung + f_zug_konstant) * v,\n", + " f_zug_konstant * fahrgeschwindigkeit_ms\n", + ")\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(t, P_momentan, label=\"Momentanleistung [W]\", color=\"crimson\")\n", + "plt.axvline(t_beschleunigung, linestyle=\"--\", color=\"gray\", label=\"Ende Beschleunigung\")\n", + "plt.axhline(f_zug_konstant * fahrgeschwindigkeit_ms, linestyle=\":\", color=\"green\", label=\"Leistung bei Konstantfahrt\")\n", + "plt.xlabel(\"Zeit [s]\")\n", + "plt.ylabel(\"Leistung [W]\")\n", + "plt.title(\"Momentanleistung während Anfahren und Konstantfahrt\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/img/Screenshot 2025-07-22 094435.png b/img/Screenshot 2025-07-22 094435.png new file mode 100644 index 0000000..55724bf Binary files /dev/null and b/img/Screenshot 2025-07-22 094435.png differ