---

Bewegungsgleichungen des Freien Falls

• Herleitung der Bewegungsgleichungen des Freien Falls,
• Links zu Skizzen und
• ein Python-Programm zum Plotten von
  Weg-, Geschwindigkeits- und Beschleunigungs-Zeit-Funktionen.

1. Physikalisches Modell des freien Falls

Wir betrachten:

• Bewegung nur in Vertikalrichtung (1D).
• Homogenes Gravitationsfeld mit konstanter Erdbeschleunigung $g$ (nahe Erdoberfläche).
• Kein Luftwiderstand.

Wähle ein Koordinatensystem:

• $y$-Achse nach oben positiv.
• Der Ursprung $y = 0$ ist z.B. der Boden.
• Die Erdbeschleunigung wirkt nach unten: $a_y = -g$.

Typischer Wert: $g \approx 9{,}81~\mathrm{m/s^2}$

Skizzen des Modells (externe Links)

• Vereinfachte Darstellung des Falls mit Geschwindigkeitsvektoren:
  Skizze: Free fall motion diagram

• Graphische Darstellung von Ort-Zeit beim Wurf nach oben (auch freier Fall):
  Skizze: Position-Time-Graph bei freiem Fall

Diese Bilder dienen nur zur Veranschaulichung des Bewegungsablaufs.

2. Grundgleichung: konstante Beschleunigung

Die newtonsche Bewegungsgleichung für den freien Fall lautet $$m,\vec a = \vec F = m,\vec g$$

Mit unserer Wahl der Richtung (nach oben positiv) gilt für die $y$-Komponente $$a_y(t) = -g$$

$g$ ist eine Konstante. Das ist die Ausgangsgleichung, aus der wir alles andere herleiten.

3. Herleitung der Geschwindigkeit-Zeit-Funktion

Definition der Beschleunigung als zeitliche Ableitung der Geschwindigkeit: $$a_y(t) = \frac{\mathrm d v_y(t)}{\mathrm d t}$$

Einsetzen von $a_y(t) = -g$: $$\frac{\mathrm d v_y(t)}{\mathrm d t} = -g$$

Das ist eine einfache Differentialgleichung 1. Ordnung. Integriere von $t = 0$ bis zu einem beliebigen Zeitpunkt $t$: $$\int_{v_y(0)}^{v_y(t)} \mathrm d v_y = \int_0^t -g ,\mathrm d t$$

Linke Seite: $$\int_{v_y(0)}^{v_y(t)} \mathrm d v_y = v_y(t) - v_y(0)$$

Rechte Seite: $$\int_0^t -g ,\mathrm d t = -g t$$

Also: $$v_y(t) - v_y(0) = -g t$$

Definiere die Anfangsgeschwindigkeit $v_{0} := v_y(0)$. Dann: $$v_y(t) = v_0 - g t$$

Das ist die Geschwindigkeit-Zeit-Funktion für den freien Fall bei beliebiger Anfangsgeschwindigkeit $v_0$.

Spezialfälle:

• Fallenlassen (Start aus der Ruhe): $v_0 = 0 \Rightarrow v_y(t) = - g t$
• Nach oben geworfener Körper: $v_0 > 0$; er wird langsamer, bis $v_y(t)=0$ (Scheitelpunkt).

4. Herleitung der Weg-Zeit-Funktion

Definition der Geschwindigkeit als zeitliche Ableitung des Ortes $y(t)$: $$v_y(t) = \frac{\mathrm d y(t)}{\mathrm d t}$$

Wir setzen $v_y(t)$ aus Schritt 3 ein: $$\frac{\mathrm d y(t)}{\mathrm d t} = v_0 - g t$$

Diese Differentialgleichung integrieren wir wieder von $0$ bis $t$. Für die linke Seite: $$\int_{y(0)}^{y(t)} \mathrm d y = y(t) - y(0)$$

Für die rechte Seite: $$\int_0^t \left(v_0 - g t'\right)\mathrm d t' = \int_0^t v_0,\mathrm d t' - \int_0^t g t',\mathrm d t'$$

Berechne die Integrale: $$\int_0^t v_0,\mathrm d t' = v_0 t$$ $$\int_0^t g t',\mathrm d t' = g \frac{t^2}{2}$$

Also: $$y(t) - y(0) = v_0 t - \frac{1}{2} g t^2$$

Definiere die Anfangsposition $y_0 := y(0)$: $$y(t) = y_0 + v_0 t - \frac{1}{2} g t^2$$

Das ist die Weg-Zeit-Funktion des freien Falls (bzw. des vertikalen Wurfs).

5. Beschleunigung-Zeit-Funktion

Wir hatten $a_y(t) = -g$ als Ausgangspunkt. Da $g$ konstant ist, gilt über die ganze Bewegung: $$a_y(t) = -g$$

Graphisch:

• Die $a(t)$-Kurve ist eine waagerechte Linie.
• Für unser Koordinatensystem (oben positiv) liegt sie unterhalb der Zeitachse bei $-g$.

6. Zusammenfassung der drei Funktionen

Allgemein (1D, vertikale Richtung, oben positiv):

• Weg: $$y(t) = y_0 + v_0 t - \frac{1}{2} g t^2$$
• Geschwindigkeit: $$v_y(t) = v_0 - g t$$
• Beschleunigung: $$a_y(t) = -g$$

Freier Fall aus der Ruhe ($v_0 = 0$) vom Startpunkt $y_0$:

• $y(t) = y_0 - \dfrac{1}{2} g t^2$
• $v_y(t) = - g t$
• $a_y(t) = -g$

7. Python-Beispielprogramm

Das folgende Programm (“2512022300_FreierFall.py”) :

• fragt dich nach Anfangshöhe $y_0$ und Anfangsgeschwindigkeit $v_0$,

• berechnet die Zeit bis zum Aufprall am Boden (vereinfachend numerisch),

• erzeugt die Zeitreihe $t$ und berechnet

  • $y(t)$ (Weg),
  • $v_y(t)$ (Geschwindigkeit),
  • $a_y(t)$ (Beschleunigung),

• zeichnet alle drei Funktionen als separate Plots mit matplotlib.

Download “2512022300_FreierFall.py.py”

import numpy as np
import matplotlib.pyplot as plt

# Physikalische Konstante
g = 9.81  # m/s^2

# Anfangsbedingungen
y0 = 50.0   # Anfangshöhe in m (z.B. 50 m)
v0 = 0.0    # Anfangsgeschwindigkeit in m/s (0 = fallenlassen)

# Optional: Benutzereingabe (kannst du auskommentieren, wenn du feste Werte willst)
# y0 = float(input("Anfangshöhe y0 in m: "))
# v0 = float(input("Anfangsgeschwindigkeit v0 in m/s (positiv nach oben): "))

# Weg-Zeit-Funktion
def y(t):
    return y0 + v0 * t - 0.5 * g * t**2

# Geschwindigkeits-Zeit-Funktion
def v(t):
    return v0 - g * t

# Beschleunigungs-Zeit-Funktion
def a(t):
    # Für den freien Fall ist a(t) konstant
    return -g * np.ones_like(t)

# Zeitachse: wir müssen wissen, wie lange der Körper in der Luft ist.
# Wir lösen y(t) = 0, um die Aufprallzeit zu finden.
# y(t) = y0 + v0 * t - 0.5 * g * t^2 = 0
# => -0.5*g*t^2 + v0*t + y0 = 0  (quadratische Gleichung)

A = -0.5 * g
B = v0
C = y0

# Diskriminante:
D = B**2 - 4 * A * C

if D < 0:
    raise ValueError("Keine reale Lösung für die Flugzeit (prüfe y0 und v0).")

t1 = (-B + np.sqrt(D)) / (2 * A)
t2 = (-B - np.sqrt(D)) / (2 * A)

# Wir brauchen die positive Zeit
t_impact_candidates = [t for t in [t1, t2] if t > 0]
if not t_impact_candidates:
    raise ValueError("Keine positive Aufprallzeit gefunden.")

t_impact = max(t_impact_candidates)

# Erzeuge Zeitarray von 0 bis Aufprallzeit
t = np.linspace(0, t_impact, 300)

# Werte berechnen
y_t = y(t)
v_t = v(t)
a_t = a(t)

# Plot 1: Weg-Zeit-Funktion
plt.figure()
plt.plot(t, y_t)
plt.xlabel("Zeit t [s]")
plt.ylabel("Höhe y(t) [m]")
plt.title("Freier Fall: Weg-Zeit-Funktion")
plt.grid(True)

# Plot 2: Geschwindigkeit-Zeit-Funktion
plt.figure()
plt.plot(t, v_t)
plt.xlabel("Zeit t [s]")
plt.ylabel("Geschwindigkeit v(t) [m/s]")
plt.title("Freier Fall: Geschwindigkeit-Zeit-Funktion")
plt.grid(True)

# Plot 3: Beschleunigung-Zeit-Funktion
plt.figure()
plt.plot(t, a_t)
plt.xlabel("Zeit t [s]")
plt.ylabel("Beschleunigung a(t) [m/s^2]")
plt.title("Freier Fall: Beschleunigung-Zeit-Funktion")
plt.grid(True)

plt.show()

Hinweise zum Experimentieren:

• Ändere $y_0$ und $v_0$, z.B.:

  • $v_0 = 10.0$ (Wurf nach oben),
  • $v_0 = -5.0$ (zusätzlicher Startimpuls nach unten).

• Du kannst $g$ variieren (z.B. $1.62~\mathrm{m/s^2}$ für den Mond), um andere Planeten zu simulieren.

---