Wellen sind ja sich in den Raum ausbreitende Schwingungen. Doch von was hängt die Ausbreitungsgeschwindigkeit der Wellen ab? Elektromagnetische Wellen breiten sich im Vakuum mit der Lichtgeschwindigkeit c = 299 792 458 m/s aus. Doch wie sieht es mit Wellen in einem Festkörper aus? Um der Frage auf den Grund zu gehen, habe ich vor rund 20 Jahren eine Simulation zur Wellenausbreitung in Turbo Pascal erstellt. Das Modell besteht aus einzelnen Atomen mit der Masse m, welche miteinander über Federn mit der Federkonstante k verbunden sind. Zum Start lenke ich das erste Atom sinusförmig aus. Danach gehorchen die einzelnen Atome der Newtonschen Bewegungsgleichung F = m·a, wobei für die Kraft F das Hooksche Federgesetz F = k·Δl eingesetzt wird. Diese Differentialgleichungen habe ich mittels der Euler-Methode iterativ gelöst. Die Bewegung der Atome ist in y-Richtung eingeschränkt. Zu Beginn einzugeben ist die Anzahl der Atome, deren Masse m und die Federkonstante k. Zudem kann noch zwischen transversaler oder longitudinaler Auslenkung ausgewählt werden und ob man die Reflexion am freien oder festen Ende möchte.
Freies oder fixes Ende beeinflusst das Reflexionsverhalten der Welle. Bei einem freien Ende wird ein Wellenberg wieder als Wellenberg reflektiert. Bei einem fixen Ende kommt ein Wellenberg als Wellental zurück.
Zur Bestimmung der Ausbreitungsgeschwindigkeit wird einfach die Zeit t notiert, bei der sich das letzte Atom ganz rechts erstmalig zu bewegen beginnt. Die Geschwindigkeit v berechnet sich dann einfach aus Pixelanzahl/Zeit t. Diese wird dann in Abhängigkeit von m bzw. k bei jeweils konstantem k bzw. m erfasst.
Wie man sieht nimmt mit zunehmender Federkonstante k die Geschwindigkeit v zu. Bei härteren Federn breitet sich also die Welle schneller aus als bei weichen Federn. Der Graph v = v(k) sieht folgendermaßen aus:
Wie sieht es bei gleicher Federkonstante k aber unterschiedlichen Massen m aus?
Hier liegt genau eine verkehrte Proportionalität vor. Je größer die Masse m der Atome, desto langsamer breitet sich die Welle aus. Steigendes m liefert also ein sinkendes v. Für den Graph v = v(m) erhält man:
Um die genaue funktionale Abhängigkeit der Geschwindigkeit v von den Größen k und m herauszufinden, geht man wiefolgt vor:
Die Potenz von k in der Formel v = v(k,m) muss daher 0.5 sein. Wie sieht es für die Potenz von m aus?
Die Potenz von m muss demnach –0.5 sein. Daher ergibt sich folgender Zusammenhang zwischen v und den Größen k und m:
In der Literatur findet man folgende Formel für die Ausbreitungsgeschwindigkeit einer Welle in einem Festkörper: 
Anstelle der Federkonstante k tritt das Elastizitätsmodul E und anstelle der Masse m die Dichte ρ. Dies leuchtet aber auch ein. Denn das Elastizitätsmodul E ist gleich der notwendigen Kraft pro m², um einen Körper der Länge L auf seine doppelte Länge zu dehnen. Daran erkennt man die Ähnlichkeit zur Federkonstante k, welche ja der Kraft F entspricht, um die Feder um einen Meter zu dehnen. Die Zusammengehörigkeit der Masse m und der Dichte ρ ist ebenfalls offensichtlich, da ja die Dichte der Masse pro m³ entspricht.
Mit dieser einfachen Simulation haben wir also eine reale Formel zur Ausbreitungsgeschwindigkeit von Wellen hergeleitet, voila…
Das uralte Turbo-Pascal-Programm:
Program Welle;
{$N+,E+}
Uses Crt,Graph,Turbo3,Dos;
Type
Feld_1 = Array[1..150] of Real;
Var { Variablendeklaration }
vx_vorher,vy_vorher : Feld_1; { Geschwindigkeitskomponenten vorher }
vx_nachher,vy_nachher : Feld_1; { Geschwindigkeitskomponenten nachher }
sx_vorher,sy_vorher : Feld_1; { Ortskomponenten vorher }
sx_nachher,sy_nachher : Feld_1; { Ortskomponenten nachher }
m : Real; { Masse der Teilchen }
k : Real; { Federkonstante }
Force_x,Force_y: Real; { Auf die Atome wirkenden Kr„fte }
delta_t,t : Real; { Zeit und Zeitintervall }
Faktor : Real; { graphischer Darstellungsfaktor }
Amplitude,Tau : Integer; { Anregungsschwingung }
zaehler,i,j : LongInt; { Z„hlvariable }
n : Integer; { Anzahl der Atome }
l_0 : Integer; { L„nge der Federn }
max : LongInt;
GraphDriver,GraphMode : Integer;
Xgraph,Ygraph : Integer;
Maxx,Maxy : Integer;
Ch,ant,Antwort_1,Antwort_2 : Char;
Pfad: String;
Weiter,Treffer,Loeschen : Boolean;
Filename: Text;
Const
NameHeader = 'Gitter , Version 1.1';
WeiterHeader= '( weiter mit beliebiger Taste )';
Pi = 3.14159265358979323846264338327950;
g = 9.81;
Esc = #27;
Rad = (2.0 * Pi / 360.0);
Procedure WriteOut(S: String);
Begin
OutTextXY(Xgraph,Ygraph,S);
Inc(Ygraph,TextHeight('M')+4);
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º STARTTEXT º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Starttext; { Starttext }
Begin
ClearDevice;
Setviewport(0,0,Maxx,Maxy,Clipon);
SetTextStyle(TriplexFont,HorizDir,3);
SetTextJustify(CenterText,TopText);
SetColor(14);
OutTextXY(Maxx div 2,30,'Programm zur Darstellung');
OutTextXY(Maxx div 2,50,'von Wellen');
SetTextStyle(TriplexFont,HorizDir,1);
OutTextXY(Maxx div 2,85,'von');
OutTextXY(Maxx div 2,105,'Dipl.Ing.Mag. Christoph Ernst');
SetLineStyle(SolidLn,0,ThickWidth);
Rectangle(30,20,595,145);
SetColor(15);
SetTextJustify(LeftText,TopText);
SetTextStyle(DefaultFont,HorizDir,1);
Ygraph := 210;
Xgraph := 40;
WriteOut('Anmerkung:');
WriteOut(' ');
WriteOut(' ');
WriteOut('Dieses Programm simuliert Seilwellen.Als Modell dienen');
WriteOut('mehrere Massen,welche mit den beiden Nachbarn ber Federn');
WriteOut('verbunden sind. Bei den transversalen Schwingungen wurde');
WriteOut('die Beweglichkeit der Massen eingeschr„nkt,sodaá sie sich nur');
WriteOut('in y-Richtung bewegen k”nnen. Viel Spaá mit dem Programm !');
SetColor(14);
SetTextJustify(CenterText,TopText);
OutTextXY((Maxx div 2), (Maxy-10),'<Esc> Programm beenden');
SetColor(15);
ant := Readkey;
If ant = Esc Then
Halt(1);
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º ABFRAGE º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Abfrage;
Begin
ClearDevice;
Setviewport(0,0,Maxx,Maxy,Clipon);
SetTextStyle(TriplexFont,HorizDir,3);
SetTextJustify(CenterText,TopText);
SetColor(14);
OutTextXY(Maxx div 2,30,'Parameter-Eingabe');
SetColor(8);
SetLineStyle(SolidLn,0,NormWidth);
Rectangle(100,20,525,70);
SetColor(7);
SetLineStyle(SolidLn,0,NormWidth);
Rectangle(102,22,523,68);
SetColor(15);
SetTextJustify(LeftText,TopText);
SetTextStyle(DefaultFont,HorizDir,1);
Ygraph := 120;
Xgraph := 2;
WriteOut(' ');
WriteOut('Es mssen im folgenden von ihnen einige Parameter eingegeben werden:');
GotoXY(1,12);
Write('Wollen sie transversale (t) oder longitudinale (l) Schwingungen untersuchen? ');
Readln(Antwort_1);
Writeln(' ');
Write('Soll die Reflexion am offenen (o) oder festen Ende (f) erfolgen? ');
Readln(Antwort_2);
Writeln(' ');
Write('Anzahl der Atome [max. 125]: ');
Repeat
Readln(n);
Until (n > 0) and (n <= 125);
Writeln(' ');
Write('Masse der Atome: ');
Readln(m);
Writeln(' ');
Write('Federkonstante k in (N/m): ');
Readln(k);
Writeln(' ');
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º Kraft º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Force(j_F,l_F: Integer;m_F,k_F: Real;x_F,y_F: Feld_1);
Var distance_links,distance_rechts : Extended;
Begin
{ Wechselwirkung zw. den Nachbaratomen }
{ ==================================== }
distance_links := SQRT((sx_vorher[j_F] - sx_vorher[j_F - 1]) *
(sx_vorher[j_F] - sx_vorher[j_F - 1]) +
(sy_vorher[j_F] - sy_vorher[j_F - 1]) *
(sy_vorher[j_F] - sy_vorher[j_F - 1]));
If (j_F < n) Then
Begin
distance_rechts := SQRT((sx_vorher[j_F] - sx_vorher[j_F + 1]) *
(sx_vorher[j_F] - sx_vorher[j_F + 1]) +
(sy_vorher[j_F] - sy_vorher[j_F + 1]) *
(sy_vorher[j_F] - sy_vorher[j_F + 1]));
End
Else
Begin
{ letztes Atom hat keinen rechten Nachbarn }
distance_rechts := l_F;
End;
If (Antwort_1 = 't') Then
Begin
{ Bei transversaler Schwingung bleiben Atome in x-Richtung fixiert! }
{ ================================================================= }
Force_x := 0.0;
End
Else
Begin
Force_x := -(distance_links - l_F) * k_F *
((sx_vorher[j_F] - sx_vorher[j_F - 1]) / distance_links) +
(distance_rechts - l_F) * k_F *
((sx_vorher[j_F + 1] - sx_vorher[j_F]) / distance_rechts);
End;
Force_y := -(distance_links - l_F) * k_F *
((sy_vorher[j_F] - sy_vorher[j_F - 1]) / distance_links) +
(distance_rechts - l_F) * k_F *
((sy_vorher[j_F + 1] - sy_vorher[j_F]) / distance_rechts);
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º Differenzen-Verfahren º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Newton(n_sub,l_sub: Integer;delta_t_sub,m_sub,k_sub : Real;VAR x0,x1,y0,y1,vx0,vx1,vy0,vy1 : Feld_1);
Var
delta_sx,delta_sy : Extended;
j_sub : LongInt;
Begin
{ Ort- und Geschwindigkeitsindizes: 0...vorher,1...nachher }
For j_sub := 2 To n_sub Do
Begin
Force(j_sub,l_sub,m_sub,k_sub,x0,y0); { Berechnung der Kraft auf das j-te Atom}
vx1[j_sub] := vx0[j_sub] + delta_t_sub * (1.0 / m_sub) * Force_x;
vy1[j_sub] := vy0[j_sub] + delta_t_sub * (1.0 / m_sub) * Force_y;
delta_sx := (vx1[j_sub] + vx0[j_sub]) * 0.5 * delta_t_sub; { gemittelte šbergabe ! }
delta_sy := (vy1[j_sub] + vy0[j_sub]) * 0.5 * delta_t_sub; { gemittelte šbergabe ! }
x1[j_sub] := x0[j_sub] + delta_sx;
y1[j_sub] := y0[j_sub] + delta_sy;
End;
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º Graphik º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Graphik(Loeschen_sub : Boolean);
Begin
If (Loeschen_sub) Then
Begin
{ Graphik loeschen }
{ ================ }
SetColor(0);
Circle(Trunc(sx_vorher[1]),Trunc(((maxy - 70) / 2) - sy_vorher[1]),8);
For j := 2 To n Do
Begin
Circle(Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]),8);
Line(Trunc(sx_vorher[j - 1]),Trunc(((maxy - 70) / 2) - sy_vorher[j - 1]),
Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]));
End;
End
Else
Begin
{ Graphik zeichnen }
{ ================ }
{
If (vx_vorher[1] >= 0) Then
Begin
SetColor(1);
Circle(Trunc(sx_vorher[1]),Trunc(((maxy - 70) / 2) - sy_vorher[1]),8);
End
Else
Begin
SetColor(2);
Circle(Trunc(sx_vorher[1]),Trunc(((maxy - 70) / 2) - sy_vorher[1]),8);
End;
}
For j := 1 To n Do
Begin
If (vx_vorher[j] = 0) Then
Begin
SetColor(3);
Circle(Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]),8);
End
else If (vx_vorher[j] > 0) Then
Begin
SetColor(1);
Circle(Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]),8);
End
Else
Begin
SetColor(2);
Circle(Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]),8);
End;
End;
For j := 2 To n Do
Begin
SetColor(15);
Line(Trunc(sx_vorher[j - 1]),Trunc(((maxy - 70) / 2) - sy_vorher[j - 1]),
Trunc(sx_vorher[j]),Trunc(((maxy - 70) / 2) - sy_vorher[j]));
End;
End;
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º º}
{º INITIALISIERUNG º}
{º º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Procedure Initialisierung; { Initialisierung s„mtlicher Parameter }
Var ErrorCode: Integer;
Begin
GraphDriver := Detect;
DirectVideo := False;
{ =============================================================== }
{ ACHTUNG : Graphik-Programme *.BGI und Schriften *.CHR mssen im }
{ Verzeichnis des auszufhrenden Programms sein !!! }
{ =============================================================== }
InitGraph (GraphDriver,GraphMode,'');
ErrorCode := GraphResult;
If ErrorCode <> grOk Then Begin
Writeln(#7,'Sorry, but I''ve a Graphics Error:');
Writeln(GraphErrorMsg(ErrorCode));
Writeln('Program intermediately stopped.');
Halt(1);
End;
SetLineStyle(SolidLn,0,Normwidth);
SetTextJustify(LeftText,TopText);
SetTextStyle(DefaultFont,HorizDir,1);
Setviewport(0,0,Maxx,Maxy,Clipon);
Maxx := Getmaxx;
Maxy := Getmaxy;
Weiter := FALSE;
End;
{ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»}
{º °°°°°°°°°°°°°°°°°°°°° º}
{º °°° HAUPTPROGRAMM °°° º}
{º °°°°°°°°°°°°°°°°°°°°° º}
{ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ}
Begin
Initialisierung;
Starttext;
ClearDevice;
Abfrage;
{ ====================================== }
{ ========Initialisierung-Anfang======== }
{ ====================================== }
l_0 := Trunc((Maxx - 100) / n); { L„nge der Federn }
{ Parameter der Erregerschwingung }
{ =============================== }
If (Antwort_1 = 'l') Then
Begin
Tau := 5;
Amplitude := 10;
End
Else
Begin
Tau := 10;
Amplitude := 50;
End;
{ Startwerte der Atome }
{ ==================== }
For zaehler := 1 To n Do
Begin
sx_vorher[zaehler] := zaehler * l_0;
sy_vorher[zaehler] := 0.0;
vx_vorher[zaehler] := 0.0;
vy_vorher[zaehler] := 0.0;
End;
Weiter := False;
t := 0.0;
delta_t := 0.005;
{ ==================================== }
{ ========Initialisierung-Ende======== }
{ ==================================== }
ClearDevice;
SetViewport(0,0,Maxx,Maxy,Clipon);
SetLineStyle(SolidLn,0,NormWidth);
SetColor(14);
SetTextStyle(DefaultFont,HorizDir,1);
SetTextJustify(CenterText,TopText);
OutTextXY((Maxx div 2),470,'< Abbruch mit Esc-Taste >');
SetTextStyle(7,HorizDir,4);
OutTextXY((Maxx div 2),9,'Wellen');
SetTextJustify(LeftText,TopText);
SetTextStyle(2,HorizDir,4);
OutTextXY(455,15,'Version 1.1');
SetColor(8);
Rectangle(0,48,Maxx - 86,Maxy - 18);
SetColor(7);
Rectangle(1,49,Maxx - 87,Maxy - 19);
SetLineStyle(SolidLn,0,NormWidth);
SetViewport(2,50,Maxx - 88,Maxy - 20,Clipon);
SetColor(7);
GotoXY(71,5);
Write('<->: slow');
GotoXY(71,6);
Write('<+>: fast');
GotoXY(71,8);
Write('t:');
{ erstmalige graph. Darstellung fr Start t = 0: }
Loeschen := False;
Graphik(Loeschen);
t := t + delta_t; { Zeit-Inkrementierung }
{ =================================== }
{ ========== Zeit-Schleife ========== }
{ =================================== }
Repeat
If Keypressed Then
Begin
ant := readkey;
Case ant of
Esc : Weiter := True;
'+' : Begin
delta_t := delta_t * 2.0;
End;
'-' : Begin
delta_t := delta_t * 0.5;
End;
End; {End Case of }
End;
{ =========================================================== }
{ Ermittlung der ver„nderten Positionen und Geschwindigkeiten }
{ durch das Unterprogramm Newton }
{ =========================================================== }
Newton(n,l_0,delta_t,m,k,
sx_vorher,sx_nachher,sy_vorher,sy_nachher,
vx_vorher,vx_nachher,vy_vorher,vy_nachher);
{ ==================================== }
{ erstes Atom folgt eine halbe Periode }
{ lang einer Sinusschwingung }
{ ==================================== }
If (Antwort_1 = 't') Then
Begin
{ transversale Erregerschwingung }
{ ============================== }
sx_nachher[1] := sx_vorher[1];
vx_nachher[1] := vx_vorher[1];
vy_nachher[1] := vy_vorher[1];
If (t <= 0.5 * Tau) Then
Begin
sy_nachher[1] := Amplitude * sin(2 * Pi * t / Tau);
End
Else
Begin
sy_nachher[1] := 0.0;
End;
End
Else
Begin
{ longitudinale Erregerschwingung }
{ =============================== }
sy_nachher[1] := sy_vorher[1];
vx_nachher[1] := vx_vorher[1];
vy_nachher[1] := vy_vorher[1];
If (t <= 0.5 * Tau) Then
Begin
sx_nachher[1] := l_0 + Amplitude * sin(2 * Pi * t / Tau);
End
Else
Begin
sx_nachher[1] := l_0 + 0.0;
End;
End;
{ letztes Atom bleibt fest oder offen }
{ =================================== }
If (Antwort_2 = 'f') Then
Begin
{ festes Ende,daher unver„nderte Koordinaten }
sx_nachher[n] := sx_vorher[n];
sy_nachher[n] := sy_vorher[n];
vx_nachher[n] := vx_vorher[n];
vy_nachher[n] := vy_vorher[n];
End;
{ Bildpunkte loeschen }
{ =================== }
Loeschen := True;
Graphik(Loeschen);
{ Wertebergabe und graphische Darstellung }
{ ======================================== }
For i := 1 To n Do
Begin
sx_vorher[i] := sx_nachher[i];
sy_vorher[i] := sy_nachher[i];
vx_vorher[i] := vx_nachher[i];
vy_vorher[i] := vy_nachher[i];
End;
Loeschen := False;
Graphik(Loeschen);
GotoXY(73,8);
Write(' ');
GotoXY(73,8);
Write(t:4:2);
t := t + delta_t;
Until Weiter;
ant := readkey;
End.
Zum Abschluss noch das Youtube-Video:
Einfache Wellenmaschinen
Variante 1:
Um die Wellenausbreitung zu studieren, kann man sich aus wenigen Teilen eine Wellenmaschine basteln. Man benötigt:
- Messingrohr 6 mm, Wandstärke 1 mm
- M3 Messingmuttern
- M3 Madenschrauben
- 3 mm Kautschukschnur
- M3 Messing Gewindestange
Der angedachte Aufbau:
Die Kautschukschnur wird durch das ca. 1 cm lange Messingrohr geführt. Auf beiden Seiten wird ein ca. 10 cm langes Stück der Messinggewindestange angelötet. Oben wird in das Rohr ein 3 mm großes Loch gebohrt. Genau darüber wird die M3 Messingmutter gelötet. In diese schraubt man dann die M3 Madenschraube, mit der das ganze Teil mit der Kautschukschnur fixiert wird. Auf die beiden Enden der Gewindestangen kommen dann zum Schluss noch einige M4-Beilagscheiben. Soweit die Theorie. Die benötigten Teile habe ich auf Amazon und im Baumarkt gekauft:
Deshalb alles aus Messing, weil ich die Teile eben anlöten möchte/muss.
Mein „professioneller“ Löttisch im Wohnzimmer:
5 Hanteln habe ich einmal gelötet und dann die 3 mm Kautschukschnur durchgefädelt:
Das Ergebnis war aber ernüchternd, die Kautschukschnur war viel zu weich, um die Verdrehung der Hanteln schön weiterzuleiten…
Daher probierte ich es mit einem 0.6 mm Kupferdraht. Dieser war aber zu steif, sodass die 5 Hanteln primär synchron dieselbe Bewegung durchführten…
Nächster Versuch, dünnes Gummiband von Action:
Funktionierte schon besser aber noch immer nicht wie gewünscht. Daher kamen als nächstes Haargummis zum Einsatz:
Dieser Versuch war schon erfolgsversprechend, allerdings sind die einzelnen, aufgeschnittenen Haargummis natürlich viel zu kurz. Zum Glück fiel mir ein, dass ich ja erst vor einem halben Jahr für die Airzooka 4 mm Gummiseil auf Amazon bestellt hatte:
Ich denke, darauf lässt sich aufbauen. Jetzt muss ich nur noch 40 weitere Hanteln per Hand löten, das kann natürlich dauern.
So, die Strafarbeit kann beginnen:
Nach dem ersten Lötdurchgang musste ich fast alle Hanteln noch einmal nacharbeiten, da die M3-Schraube fast immer nicht genau senkrecht zu den Gewindestangen stand…
Der erste Aufbau am Küchentisch unter Verwendung von zwei Schraubzwingen und Lüsterklemmen zur Fixierung des Gummiseils:
Leider waren die Ergebnisse alles andere als berauschend. Die Schwingung wurde zwar weitergegeben, aber insgesamt war die Dämpfung deutlich zu stark 🙁
Ehrlich gesagt weiß ich nicht, ob ich diesen gewählten Ansatz noch weiterverfolgen soll. Die über 30 Hanteln haben in Summe auch ein erhebliches Gewicht, sodass das Gummiseil schon ordentlich gespannt werden muss. Eine höhere Vorspannung würde wohl auch die Weitergabe der Schwingung unterstützen. Da werde ich noch ein wenig herumexperimentieren. Vielleicht kaufe ich mir auch noch einen Polyurethanriemen auf Amazon: https://www.amazon.de/-/en/Kuuleyn-Polyurethane-Conveyor-Surface-Transmission/dp/B091B6S2BN.
Ich habe heute noch alle längeren M3-Schrauben + Beilagscheiben entfernt und stattdessen nur kurze Madenschrauben verwendet. Dadurch wurde zwar das Ganze deutlich leichter, aber es änderte sich eigentlich nichts an der schlechten Wellenausbildung. Daher kann ich diesen Ansatz mit nur einer Gummischnur, welche eben leicht verdrillt wird, vergessen…
Variante 2:
Im Internet bin ich auf eine andere, sehr einfache Variante gestoßen. Diese verwendet lediglich Panzerklebeband, Holzspieße und Fruchtgummis. Das musste ich natürlich gleich selbst ausprobieren und habe mir daher 5 Packungen Haribo Frösche besorgt:
Schaschlikspieße und Panzerband hatte ich zum Glück bereits zuhause:
Beim Panzerband gibt es doch qualitativ erhebliche Unterschiede von totaler Murks bis hin zu sehr brauchbar. Dieses hier klebte leider nur sehr schwach aber ich probierte es dennoch…
Das größte Problem waren die eingeschränkten Platzverhältnisse in meiner kleinen Wohnung. Ein Ende des Klebebands machte ich auf meinem Küchentisch fest, das andere fixierte ich auf meiner Dobson-Fernrohrmontierung. Zuerst probierte ich die Wellenmaschine ohne Haribo-Süßigkeiten. Die Wellengeschwindigkeit war wie zu erwarten war sehr hoch:
Danach spießte ich die ca. 120 Frösche auf, wobei man darauf achten muss, dass sich das Klebeband bzw. die Spieße schön horizontal ausrichten. Gegebenenfalls muss man die Frösche auf den Holzspießen verschieben…
Mit dem Ergebnis bin ich eigentlich zufrieden. Die Wellengeschwindigkeit war nun deutlich geringer. Man erkennt sehr schön die Ausbreitung bzw. Reflexion der Welle, Heureka…
Variante 3:
Der Aufbau der dritten Variante ist ähnlich simpel, denn es werden nur zwei Gummibänder und viele Holzstäbe benötigt.
Der große Vorteil dieser Variante ist, dass sich einerseits die Holzstäbe automatisch durch die beiden Gummiseile horizontal ausrichten und andererseits die Wellenausbreitung nicht durch Torsion des Gummibands zustande kommt, sondern durch Dehnung. Die Holzstäbe besorge ich im Baumarkt, Gummiseil habe ich ja bereits zuhause…
Wenn es Neuigkeiten gibt, geht es hier weiter…
