====== Auswertung Gruppe 310 - Besenstiel ======
Der Versuch wurde durchgeführt von: Erin Feldkemper und Arthur Wohlfahrt \\
Die Wiki-Seite wurde angelegt am: @DATE@
**In diesem Wiki soll die Durchführung des Besenstiel-Versuches im HomeLab dokumentiert werden**
===== Vorüberlegungen =====
In diesem Experiment wollen wir die Fallbewegung eines kippenden Besenstiels untersuchen. Hierfür machen wir zunächst ein paar Vorüberlegungen.
Wir wollen erst einmal die Kippbewegung mithilfe von physikalischen Begriffen beschreiben.
Wir wissen, dass die Masse des Stabes homogen über seine Länge verteilt ist, und somit der Schwerpunkt in der Stabmitte liegt.
Wenn der Stab nun umkippt, verläuft die Bewegung nicht geradlinig. Stattdessen handelt es sich um eine Drehbewegung nach unten um den Kontaktpunkt herum. Der Kontaktpunkt stellt hierbei die Stelle dar, an der der Besenstiel den Boden berührt. \\
Das Moment, welches auf den Stab wirkt, setzt sich also aus der Kraft und dem Hebelarm a zusammen. Die Kraft lässt sich in parallele und senkrechte Anteile relativ zum Stab zerlegen.
Es gilt:
\begin{align*}
\vec{M} & = \vec{F} \times \vec{a} \\
F & = m\cdot g = mg\cdot (sin(\phi)+cos(\phi))\\
a & = \frac{L}{2} \\
=> M &= m\cdot g\cdot sin(\phi)\cdot\frac{L}{2}
\end{align*}
Da nur der Anteil der Kraft senkrecht zum Stab zum Drehmoment beiträgt und dieser mit größerem Winkel ebenfalls ansteigt, beschleunigt der Stab immer schneller.
Für die Fallzeit gilt: Je kleiner der Anfangswinkel ist, desto größer ist die Kippzeit T.
Wenn man die Luftreibung vernachlässigt, so hängt bei gleicher Stablänge die Kippzeit $T$ nicht von der Stabmasse $m$ ab.
Das Drehmoment M einer Drehbewegung kann man über $M = J\cdot b$. Wobei es sich bei $J$ um das Trägheitsmoment und bei $b$ um die Winkelbeschleunigung handelt.
Wir betrachten nun das Trägheitsmoment einer Punktmasse $m$ in einem gewissen Abstand $L$ um eine Drehachse, es gilt:
\begin{align*}
J & = m \cdot L^{2}
\end{align*}
Unsere Masse ist nun aber homogen über die gesamte Länge $L$ verteilt, es gilt also $J=\frac{m}{L}\cdot L^2$ und wenn wir hierüber integrieren von 0 bis L erhalten wir:
\begin{align*}
J & = \frac{1}{2} m \cdot L^2
\end{align*}
Setzt man nun die Formel $M=J\cdot b$ nach J um und setzt $M=m\cdot g\cdot sin(\phi)\cdot\frac{L}{2}$ ein, erhalten wir:
\begin{align*}
b & = \frac{3}{2}\cdot g\cdot\frac{1}{L}\cdot sin(\phi)
\end{align*}
Es ist also eindeutig, dass die Winkelbeschleunigung $b$ nicht von der Masse abhängig ist, und dementsprechend ist auch die Fallzeit $T$ nicht von der Masse abhängig. \\
Weiterhin sehen wir, dass je größer die Stablänge $L$ wird, desto kleiner wird die Winkelbeschleunigung $b$ und dadurch die Fallzeit $T$ größer. \\
Die Stablänge beeinflusst also die Zeit die der Stab zum Fallen benötigt.
Aus diesen Experimenten lässt sich schlussfolgern, dass das Jonglieren/Balancieren leichter ist, wenn der Stab länger ist, da dadurch die Kippzeit größer ist.\\
Es besteht dann also eher die Möglichkeit, das "Wegkippen" des Stabes durch eine Bewegung auszugleichen, da man mehr Zeit dafür hat.
==== Messung 1 ====
^ Winkel in ° ^L=16.7cm| | | | | |
| 27 | 0.148 | 0.142 | 0.153 | 0.158 | 0.148 | 0.154 |
| 6 | 0.334 | 0.331 | 0.335 | 0.327 | 0.332 | 0.331 |
| 14.5 | 0.214 | 0.224 | 0.218 | 0.222 | 0.222 | 0.224 |
| 19.5 | 0.186 | 0.187 | 0.191 | 0.187 | 0.195 | 0.185 |
| 25 | 0.157 | 0.161 | 0.154 | 0.161 | 0.163 | 0.162 |
| 31 | 0.137 | 0.135 | 0.134 | 0.139 | 0.134 | 0.136 |
| 38.5 | 0.109 | 0.114 | 0.112 | 0.114 | 0.114 | 0.111 |
| 48.5 | 0.097 | 0.094 | 0.093 | 0.093 | 0.092 | 0.089 |
Stab 2, langer Stab: L=132cm
^ +/- 2[°] | | | | | | |
| 2 | 1.148 | 1.178 | 1.158 | 1.164 | 1.164 | 1.175 |
| 5 | 0.934 | 0.932 | 0.931 | 0.935 | 0.961 | 0.953 |
| 11 | 0.735 | 0.74 | 0.739 | 0.735 | 0.735 | 0.733 |
| 15 | 0.672 | 0.672 | 0.671 | 0.672 | 0.677 | 0.671 |
| 25 | 0.571 | 0.572 | 0.571 | 0.577 | 0.591 | 0.588 |
| 32.5 | 0.485 | 0.595 | 0.587 | 0.592 | 0.484 | 0.497 |
===== Aufbau 1 =====
Zur Messung der Fallzeit haben wir uns für eine Lichtschranke entschieden. An einem Ausleger und einer Bodenstation wird so die Fallzeit des Besens gemessen. Ein Arduino-Uno Mikrocontroller übernimmt das Auslesen der Lichtschranken und die Zeitmessung zwischen den Signalen.
== Aufbau schematisch ==
Der eingezeichnete Ausleger dient zur Einstellung eines festen Startwinkels und gleichzeitig als Halterung für die Lichtschranke.
Die Winkelmessung geschieht mittels Geodreieck mit einer Genauigkeit von ca. 1-2°.
{{:a_mechanik:kippender_besenstiel:gruppenseiten:gruppe310:besenstiel_fallanlage.jpg?direct&600|}} //
//
== Aufbau für kleine Längen ==
Mit diesem Aufbau konnte auch die Fallzeit eines Stiftes erfolgreich untersucht werden.
Vorn im Bild ist der Arduino-Uno und die Schaltung zu sehen.Es folgt der winkelverstellbare Trägerarm und zur Anzeige der Messwerte via serielle Schnittstelle ein Laptop.
Zum Betrieb der Lichtschranken werden LED/kleine Laserdioden verwendet.
Aufbaubedingt hat die untere Lichtschranke einen Abstand zum Boden von ca. (2.5±0.1)cm. Bedingt dadurch verkürzt sich die Zeitmessung.
{{:a_mechanik:kippender_besenstiel:gruppenseiten:gruppe310:aufbau_klein_1.jpg?direct&600|}}
//
== Aufbau für große Längen ==
Gleiches Prinzip, wie eben. Hier dient der Tisch als Stabilisierung. Zu beachten ist, dass durch die Gymnastikmatte die effektive Höhe der Lichtschranke 1cm tiefer liegt.
{{:a_mechanik:kippender_besenstiel:gruppenseiten:gruppe310:aufbau_gross.jpg?direct&600|}}
//
== Lichtschranke ==
{{:a_mechanik:kippender_besenstiel:gruppenseiten:gruppe310:aufbau_gross_lichtschranke.jpg?direct&600|}}
//
==== Schaltung ====
=== Computerprogramm ===
Das Zeitschrittverfahren oder auch Euler-Verfahren zur numerischen Berechnung der Fallzeit wurde mit Python realisiert.
Code (samt Kommentaren) und resultierende Plots sind eingefügt.
[[doku>wiki:syntax#syntax_highlighting|englische Variante]]
Zunächst zur allg. Berechnung des Winkels in Abhgkt. zur Zeit und Überprüfung mit Beispielwerten.
Ausgabeplots im beiliegenden Bericht.
import numpy as np
import matplotlib.pyplot as plt
import math
#Variablen und Konstanten
tmax=2
dt=0.01 #10 ms
g=9.81
l=1.45 # m
tau=math.sqrt(2*l/(3*g))
vPhi0=0 #zero initial phi-velocity
phi0=0.25
t=[]
phi=[]
vPhi=[]
# initial values
phi.append(phi0)
vPhi.append(vPhi0)
i=0
#Explizites Euler Verfahren/ Iteration
while True:
vPhi.append(vPhi[i] +dt*math.sin(phi[i])/(tau**2))
phi.append(phi[i]+dt*vPhi[i])
i+=1
if phi[i] >= math.pi/2:
break
# Berechnung Auftreffzeitpunkt
tmax=len(phi)*dt
print(tmax)
#erzeuge Zeiten
t=np.arange(0,tmax,dt)
# Erzeuge eine Figure.
fig = plt.figure(figsize=(9, 4))
fig.set_tight_layout(True)
# Plotte das Winkel-Zeit-Diagramm.
ax1 = fig.add_subplot(1, 1, 1)
ax1.set_xlabel("t [s]")
ax1.set_ylabel("phi [rad]")
ax1.grid()
#ax1.plot(t, vPhi, ".b", label="Vphi")
ax1.plot(t, phi, ".r", label="Phi")
ax1.legend()
plt.show()
Nun zur Untersuchung des Einflusses der Schrittweite und der Fallzeit für verschiedene Anfangswinkel. Dazu wird das Zeitschrittverfahren in einer Methode implementiert.
Auch hier sind die resultierenden Plots im Bericht zu finden.
import numpy as np
import matplotlib.pyplot as plt
import math
#variables and constants
tmax=2
dt=0.01 #stepsize
g=9.81
l=1.45 # m
tau=math.sqrt(2*l/(3*g))
vPhi0=0 #zero initial phi-velocity
#method to solve the diff-eq.
def solver2(phi0,stepT):
t=[] #generate lists
phi=[]
vPhi=[]
# initial values
phi.append(phi0)
vPhi.append(vPhi0)
i=0
while True: #iterations according to Euler
vPhi.append(vPhi[i] +stepT*math.sin(phi[i])/(tau**2))
phi.append(phi[i]+stepT*vPhi[i])
i+=1 #next step
if phi[i] >= math.pi/2: # stick has reached ground at 90°
break
tmax=len(phi)*stepT #calculate elapsed time
t=np.arange(0,tmax,stepT)
return (tmax,t,phi) #return tupel with fall-time + time and angle arrays
#initial angles
initPhi=np.arange(0.25,1.3,0.05)
def calcTs(step): #calc the fall time for different initial phi
ts=[]
for i in initPhi: #generate list of times
ts.append(solver2(i,step)[0]) #first element in return tuple is tmax
return ts
steps=np.array([0.1,0.05,0.01,0.001])
times=[]
for m in steps:
times.append(calcTs(m))
# Erzeuge eine Figure.
fig = plt.figure(figsize=(7, 5))
fig.set_tight_layout(True)
# Plotte das Diagramm.
ax1 = fig.add_subplot(1, 1, 1)
ax1.set_xlabel("phi0 [rad]")
ax1.set_ylabel("T [s]")
ax1.grid()
ax1.plot(initPhi, times[0], ".b", label=f"dt={steps[0]}")
ax1.plot(initPhi, times[1], ".r", label=f"dt={steps[1]}")
ax1.plot(initPhi, times[2], ".g", label=f"dt={steps[2]}")
ax1.plot(initPhi, times[3], "xm", label=f"dt={steps[3]}")
ax1.legend()
#anzeigen
plt.show()
==== Arduino Code ====
Die verwendete Lichtschranke wurde mit dem Microcontroller-Board Arduino Uno realisiert.
Mit einer Kalibrierung der Lichtschranken, wurden die Auslösegrenzen an die jeweiligen Lichtverhältnisse angepasst.
Bei Aktivierung der Ausgabe der internen Zeitmessung konnte eine Totzeit von 6-8ms zwischen den Schleifendurchläufen in der Main-Loop und damit zwischen den Messungen ermittelt werden.
/*
Control two light barriers, connected to pin A0 and A2 (arduino UNO)
Indicator leds are connected to pin 12 and 13.
Measure time in ms between to detections of the upper/lower light barrier.
27.12.2020
*/
boolean dectUp = false;
boolean dectLow = false;
boolean timer = false; //timer running?
int trigUp = 700;
int trigLow = 950;
unsigned long deltaT = 0;
unsigned long t = 0;
unsigned long deltaTU = 0;
unsigned long tU = 0;
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
pinMode(12, OUTPUT); //indicator low
pinMode(13, OUTPUT); //indicator high
}
void loop() {
// read the input on analog pin 0:
int valueLow = analogRead(A0);
int valueUp = analogRead(A2);
// print out the value you read:
/*Serial.print(valueLow);
Serial.print(" | oben: ")
Serial.println(valueUp);
*/
//delay(100); // delay in between reads for stability
if (valueUp < trigUp) { // upper sensor
//Serial.println("Ready");
if (dectUp && timer == false) { //first light after dark and timer not running
Serial.println("Rest");
Serial.println(millis() - t);
t = millis(); //start timer
timer = true; //timer on
Serial.println("Start");
}
digitalWrite(13, HIGH);
dectUp = false;
}
else { // Dark UP
//Serial.println("Detected");
digitalWrite(13, LOW);
delay(5); // detection break
dectUp = true;
timer = false; //timer off
}
//Serial.print("time-complexity: ");
//Serial.println(millis()-tU);
//tU = millis();
if (valueLow < trigLow) { //lower sensor
digitalWrite(12, HIGH);
//Serial.println("Ready");
dectLow = false;
}
else { // Dark LOW
//Serial.println("Detected");
if (!dectLow && timer) { //first dark after light
deltaT = millis() - t;
timer = false; //timer off
Serial.print("Detected: ");
Serial.println(deltaT);
}
digitalWrite(12, LOW);
//delay(1); // detection break
dectLow = true;
}
}
==== Vorgehen - Messung 2 ====
Um die Fallzeit des Besenstiels mit der Länge l=1.2(m) zu bestimmen, wurden auf dem Boden eine Markierung neben den Schreibtisch gemacht um den Besenstiel immer vom gleichen Ort fallen lasse zu können. Auf dem Schreibtisch wurden 5 verschiedene Markierungen geklebt um verschiedene Winkel messen zu können (siehe Foto).
Anschließend wurden mithilfe der App "iLevel" die Winkel bestimmt und pro Winkel werden nun jeweils 5 Fallzeiten manuell aufgenommen (siehe Tabelle).
{{img_0152.jpg?500}}
^ | **98.0°** | **115.4°** | **127.3°** | **136.8°** | **143.4°** |
| 1. | 0.93 | 0.69 | 0.91 | 0.65 | 0.64 |
| 2. | 1.07 | 0.64 | 0.65 | 0.83 | 0.46 |
| 3. | 0.97 | 0.79 | 0.56 | 0.75 | 0.37 |
| 4. | 0.99 | 0.7 | 0.63 | 0.48 | 0.49 |
| 5. | 1.09 | 0.76 | 0.74 | 0.53 | 0.49 |
Wir haben uns jedoch dazu entschlossen in unserer Auswertung nur die Messwerte der ersten Messung zu werden um gleiche Fehlerabschätzungen zu haben, und bessere Aussagen treffen zu können.