M.1.B

Video

Konventionen

Winkelposition: Winkel mit Zählrichtung und Nullpunkt zur Beschreibung der Lage eines Zeigers.
Zählrichtung: Im Uhrzeigersinn.
Nullpunkt: 12-Uhr-Position.

Berechnen Sie die Winkelgeschwindigkeit und die Drehzahl für jeden der drei Zeiger.

Beobachtungen

Alle Zeiger ändern ihre Winkelposition zeitlich. Alle Zeiger drehen sich von der \(30^\circ\)-Winkelposition auf die \(120^\circ\)-Winkelposition.

Zwischen diesen beiden Winkelpositionen wird bei allen Zeigern der Winkel \(\Delta\varphi=90^\circ\) abgestrichen. Und das ist entspricht einer Viertel Umdrehung, also \(\tfrac 1 4 \mathrm{U}\).

Die Zeiger drehen sich unterschiedlich schnell, sodass unterschiedlich viel Zeit \(\Delta t\) vergeht, während sich der jeweilige Zeiger um \(90^\circ\) dreht:

Stundenzeiger: \(\Delta t = 3\,\mathrm{h}=3\cdot 3600\,\mathrm{s} = \boldsymbol{10800\,\mathrm{s}}\)
Minutenzeiger: \(\Delta t = 15\,\mathrm{min}=15\cdot60\,\mathrm{s} = \boldsymbol{900\,\mathrm{s}}\)
Sekundenzeiger: \(\Delta t = \boldsymbol{15\,\mathrm{s}}\)

Die Winkelgeschwindigkeit \(\omega\) ist definiert als die zeitliche Änderung der Winkelposition. Und die Drehzahl \(n\) [1] ist definiert als die zeitliche Änderung der Anzahl der Umdrehungen.

Jeder der drei Zeiger hat eine eigene Winkelgeschwindigkeit und eine eigene Drehzahl.

Ergebnisse

Stundenzeiger

\begin{align*} \left(\tfrac{\Delta\varphi}{\Delta t}, \tfrac{\Delta N}{\Delta t}\right) = \left(\omega, n\right) &= \left( \tfrac{90^\circ}{\boldsymbol{10800\,\mathrm{s}}}, \tfrac{\tfrac 1 4\,\mathrm{U}}{\boldsymbol{10800\,\mathrm{s}}}\right)\\ &= \left( \tfrac{30^\circ}{{\mathrm{h}}} , \tfrac{\tfrac{1}{12}\,\mathrm{U}}{{\mathrm{h}}} \right)\\ &= \left( \tfrac{\tfrac 1 2 ^\circ}{{\mathrm{min}}}, \tfrac{\tfrac{1}{720}\,\mathrm{U}}{{\mathrm{min}}} \right) \\ &= \left( \tfrac{\tfrac{1}{120}^\circ}{{\mathrm{s}}} , \tfrac{\tfrac{1}{43200}\,\mathrm{U}}{{\mathrm{s}}} \right) \\ \end{align*}

Minutenzeiger

\begin{align*} \left(\omega, n\right) &= \left( \tfrac{90^\circ}{\boldsymbol{900\,\mathrm{s}}}, \tfrac{\tfrac 1 4\,\mathrm{U}}{\boldsymbol{900\,\mathrm{s}}}\right)\\ &= \left( \tfrac{360^\circ}{{\mathrm{h}}} , \tfrac{1\,\mathrm{U}}{{\mathrm{h}}} \right)\\ &= \left( \tfrac{6^\circ}{{\mathrm{min}}}, \tfrac{\tfrac{1}{60}\,\mathrm{U}}{{\mathrm{min}}} \right)\\ &= \left( \tfrac{\tfrac{1}{10}^\circ}{{\mathrm{s}}} , \tfrac{\tfrac{1}{3600}\,\mathrm{U}}{\mathrm{s}} \right) \\ \end{align*}

Sekundenzeiger

\begin{align*} \left(\omega, n\right) &= \left( \tfrac{90^\circ}{\boldsymbol{15\,\mathrm{s}}}, \tfrac{\tfrac 1 4\,\mathrm{U}}{\boldsymbol{15\,\mathrm{s}}}\right)\\ &= \left( \tfrac{21600^\circ}{{\mathrm{h}}} , \tfrac{60\,\mathrm{U}}{{\mathrm{h}}} \right)\\ &= \left( \tfrac{360^\circ}{{\mathrm{min}}}, \tfrac{1\,\mathrm{U}}{{\mathrm{min}}} \right)\\ &= \left( \tfrac{6^\circ}{{\mathrm{s}}} , \tfrac{\tfrac{1}{60}\,\mathrm{U}}{{\mathrm{s}}} \right) \\ \end{align*}

Ergebnistabelle

Winkelgeschwindigkeit
	\(\omega \, / \, \tfrac{^\circ}{\mathrm{h}}\)	\(\omega \, / \, \tfrac{^\circ}{\mathrm{min}}\)	\(\omega \, / \, \tfrac{^\circ}{\mathrm{s}}\)
Stundenzeiger	\(30\)	\(\tfrac{1}{2}\)	\(\tfrac{1}{120}\)
Minutenzeiger	\(360\)	\(6\)	\(\tfrac{1}{10}\)
Sekundenzeiger	\(21600\)	\(360\)	\(6\)

Drehzahl
	\(n \, / \, \tfrac{^\mathrm{U}}{\mathrm{h}}\)	\(n \, / \, \tfrac{^\mathrm{U}}{\mathrm{min}}\)	\(n \, / \, \tfrac{^\mathrm{U}}{\mathrm{s}}\)
Stundenzeiger	\(\tfrac{1}{12}\)	\(\tfrac{1}{720}\)	\(\tfrac{1}{43200}\)
Minutenzeiger	\(1\)	\(\tfrac{1}{60}\)	\(\tfrac{1}{3600}\)
Sekundenzeiger	\(60\)	\(1\)	\(\tfrac{1}{60}\)

Umrechnung

Umrechnung zwischen Winkelgeschwindigkeit \(\omega\) und Drehzahl \(n\):

\[\omega = n \tfrac{360^\circ}{\mathrm{U}} \quad \Leftrightarrow \quad n = \omega\tfrac{\mathrm{U}}{360^\circ}\]

Fußnote

SymPy

Source Code eines Programms dazu:

from sympy.physics.units import *
from sympy import *

# Units:
(mm, cm)  =  ( m/1000, m/100 )
Newton    =  kg*m/s**2
kN        =  10**3*Newton
Pa        =  Newton/m**2
MPa       =  10**6*Pa
GPa       =  10**9*Pa
deg       =  pi/180
half      =  S(1)/2

# Rounding:
def iso_round(x, pv):
    try:
        x = float(x)
        tmp = round(x, pv)
    except TypeError:
        from functools import partial
        func = partial(round, ndigits = pv)
        tmp = x.applyfunc(func)
    return tmp

# ---

h, min = 3600*s, 60*s

# Output precision:
prec = 2

pprint("\nAng. Velocities (ω₁, ω₂, ω₃):")
wh, wmin, ws = 30*deg / h, 30*deg / (5*min), 30*deg / (5*s)
w = Matrix([wh, wmin, ws])
pprint("\nin ° / h:")
tmp = w / (deg/h)
pprint(tmp)

pprint("\nin ° / min:")
tmp = w / (deg/min)
pprint(tmp)

pprint("\nin ° / s:")
tmp = w / (deg/s)
pprint(tmp)

pprint("\nin rad / s:")
tmp = w / (1/s)
pprint(tmp)

tmp = iso_round(tmp, 4)
pprint(tmp)


pprint("\nRevolutions per Time (n₁, n₂, n₃):")

pprint("\nin U / h")
tmp= w / (2*pi) * 3600*s
pprint(tmp)

pprint("\nin U / min")
tmp = w / (2*pi) * 60*s
pprint(tmp)

pprint("\nin U / s")
tmp = w / (2*pi) * 1*s
pprint(tmp)

pprint("\n---")

pprint("\nWallclock Time:")
tC = "00:00:05"
tC = "01:30:00"
tC = "03:00:05"

tmp = tC.split(":")
tmp = list(map(int,tmp))
nh, nmin, ns = tmp[0], tmp[1], tmp[2]
assert(nh in range(0,24))
assert(nmin in range(0,60))
assert(ns in range(0,60))
dt = nh * h + nmin * min + ns * s
pprint(tC)
pprint("\nElapsed Time: Δt / s:")
tmp = dt / s
pprint(tmp)

pprint("\nSwept Angles ( φɴ₁, φɴ₂, φɴ₃ ) / °:")
p_in_deg = w*dt /deg
tmp = p_in_deg
pprint(tmp)
pprint("\nRounded:")
pprint(iso_round(tmp, prec))

pprint("\nAngular Positions ( φ₁, φ₂, φ₃ ) / ° ∈ [0, 360[:")
mod = lambda x: x%360     # modulo
tmp = p_in_deg
tmp = tmp.applyfunc(mod)
pprint(tmp)
pprint("\nRounded:")
pprint(iso_round(tmp, prec))

pprint("\nNumber of 360°-Rotations (N₁, N₂, N₃):")
tmp = p_in_deg
tmp /= 360.
pprint("\nRounded:")
pprint(iso_round(tmp, prec))

Programm ausführen? Dazu:

Copy: Source Code in die Zwischenablage kopieren.
Paste: Source Code ins Eingabefeld hinter [ ]: einfügen.
Play: Knopf ▶ drücken.