Tags: , , , ,


AUFGABE 1: Axiale Spannungen und Verformungen

Problembeschreibung

Eine starre Platte $\mathit{B}$ ist an den beiden Stäben $\mathit{A}$ und $\mathit{C}$ befestigt, wie in Abbildung 1 dargestellt. Der Stab $\mathit{C}$ ist an dem Stab $\mathit{D}$ befestigt, dessen Ende an einem starren Träger befestigt ist. Das Ende des Stabes $\mathit{A}$ ist frei. $l_{A}$, $l_{C}$, $l_{D}$ sind die Längen der Stäbe $\mathit{A}$, $\mathit{C}$ bzw. $\mathit{D}$, und ihre Durchmesser sind $d_{A}=d$, $d_{C}=d$ und $d_{D}=1,5d$. Die Last $F_{1}$ wird auf die starre Platte $\mathit{B}$ $($gleichmäßig um den Umfang der starren Platte $\mathit{B})$ verteilt, und die Last $F_{2}$ wird im Schwerpunkt des Endquerschnitts des Stabs $\mathit{B}$ aufgebracht.

Figure 1
Abbildung 1: Axialer Stab unter Belastung

Projektziele

Bestimmung der Axialspannungen in den Stäben $\mathit{A}$, $\mathit{C}$ und $\mathit{D}$, Verformungen der Stäbe und Gesamtverformung des Systems.

Für die numerische Anwendung könnten die folgenden Werte verwendet werden:

  • $F_{1} = 64000 \hspace{1pt} N$
  • $F_{2} = 192000 \hspace{1pt} N$
  • $d = 45 \hspace{1pt} mm$
  • $l_{A} = 170 \hspace{1pt} mm$
  • $l_{C} = 144.5 \hspace{1pt} mm$
  • $l_{D} = 255 \hspace{1pt} mm$
  • Elastizitätsmodul $E = 21\cdot10^4 \hspace{1pt} MPa$

Lösung

Analytische Lösung

Der Stab wird in Komponenten unterteilt, und die Schnittgrößen werden berechnet, indem Abschnitte durch jede Komponente geführt werden. Für Teile des Stabs werden Freikörperdiagramme erstellt, wie in Abbildung 2A dargestellt.

Figure 2
Abbildung 2: Freikörper-Diagramme

Das Freikörperdiagramm des Systems, nämlich Stab $\mathit{D}$, Stab $\mathit{C}$, Platte $\mathit{B}$ und Stab $\mathit{A}$, enthält nur eine unbekannte Kraft, nämlich die Reaktionskraft $\mathit{R}$ an der starren Auflage. Aus der Gleichgewichtsgleichung des Systems ergibt sich die Reaktionskraft $\mathit{R}$, also die Reaktionskraft der starren Lagerung auf den Stab D:

  • $\sum_{}^{}\mathrm{F}_{x}^{A,B,C,D}=0$
  • $\Leftrightarrow R+F_{1}-F_{2}=0$
  • $\Leftrightarrow R = F_{2}-F_{1}$

Das MATLAB-Programm beginnt mit der Deklaration von Variablen als symbolische skalare Variablen mit Hilfe der syms-Funktion:

Untitled
clear; clc; close all
syms F_1 F_2
syms d_A d_C d_D d E l_A l_C l_D

Dann werden die Schnittgrößen für jeden Teil des Stabes berechnet. Die Gleichgewichtsgleichung des Freikörperdiagramms für den Stab $A$, im Intervall $3-4$, Abbildung 2B, ergibt die Schnittkraft $T_{34}$:

  • $\sum_{}^{}\mathrm{F}_{x}^{}=0$
  • $\Leftrightarrow T_{34}-F_{2}=0$
  • $\Leftrightarrow T_{34}=F_{2}$

Für den Bereich 1-3, Abbildung 2C, ergibt die Gleichgewichtsgleichung des Freikörperdiagramms die innere Kraft $T_{13}$:

  • $\sum_{}^{}\mathrm{F}_{x}^{}=0$
  • $\Leftrightarrow T_{13}+F_{1}-F_{2}=0$
  • $\Leftrightarrow T_{13}=F_{2}-F_{1}$

Die oben ermittelten Gleichgewichtsgleichungen werden in MATLAB wie folgt geschrieben:

Untitled
T_34 = F_2;
T_13 = F_2-F_1;

Die Querschnittsflächen der einzelnen Stäbe $A$, $C$ und $D$ werden wie folgt berechnet:

  • $A_{A}=\frac{\pi d_{A}^{2}}{4}$
  • $A_{C}=\frac{\pi d_{C}^{2}}{4}$
  • $A_{D}=\frac{\pi d_{D}^{2}}{4}$

In MATLAB werden die Querschnittsflächen berechnet und die Ergebnisse ausgedruckt:

Untitled
d_A = d;
d_C = d;
d_D = 1.5*d;
 
A_A = pi*(d_A^2)/4;
A_C = pi*(d_C^2)/4;
A_D = pi*(d_D^2)/4;
fprintf('A_A = $s \n', char(A_A))
fprintf('A_C = $s \n', char(A_C))
fprintf('A_D = $s \n', char(A_D))
fprintf('\n')
 

Die Axialspannungen an den Stäben $A$, $C$, $D$, nämlich $\sigma_{A}$, $\sigma_{C}$ und $\sigma_{D}$, werden berechnet unter Verwendung:

  • $\sigma_{A}=\sigma_{34}=\frac{T_{34}}{A_{A}}=\frac{F_{2}}{A_{A}}=\frac{4F_{2}}{\pi d_{A}^{2}}$
  • $\sigma_{C}=\sigma_{23}=\frac{T_{13}}{A_{C}}=\frac{F_{2}-F_{1}}{A_{C}}=\frac{4(F_{2}-F_{1})}{\pi d_{C}^{2}}$
  • $\sigma_{D}=\sigma_{12}=\frac{T_{13}}{A_{D}}=\frac{F_{2}-F_{1}}{A_{D}}=\frac{4(F_{2}-F_{1})}{\pi d_{D}^{2}}$

In MATLAB werden die Axialspannungen berechnet durch:

Untitled
sigma_A=T_34/A_A;
sigma_C=T_13/A_C;
sigma_D=T_13/A_D;
fprintf('sigma_A = %s \n',char(sigma_A))
fprintf('sigma_C = %s \n',char(sigma_C))
fprintf('sigma_D = %s \n',char(sigma_D))
fprintf('\n')

Unter Berücksichtigung der folgenden Punkte:

  • Hookesches Gesetz der Elastizität: $\sigma=E\epsilon$, d. h. für kleine Verformungen ist die Spannung direkt proportional zur Dehnung (die sie hervorgerufen hat),
  • und der Ausdruck für die elastische Dehnung: $\epsilon=\frac{\delta}{l}$, wobei $l$ die Länge des Stabes, $\epsilon$ das griechische Symbol für die Dehnung (dimensionslos) und $\delta$ die Gesamtdehnung (oder die Dehnung des Stabes) ist,

werden die axialen Verschiebungen (d. h. die Dehnung, die sich bei Zugbelastung eines geraden Stabes ergibt) der Stäbe $C$, $D$ und des Systems berechnet:

  • Axiale Verschiebung des Stabes $D$:
  • $$ \delta_{12}=\frac{T_{13}l_{D}}{A_{D}E}=\frac{(F_{2}-F_{1})l_{D}}{A_{D}E} $$
  • Axiale Verschiebung des Stabes $C$:
  • $$ \delta_{23}=\frac{T_{13}l_{C}}{A_{C}E}=\frac{(F_{2}-F_{1})l_{C}}{A_{C}E} $$
  • Axiale Verschiebung der Stäbe $D$ und $C$:
  • $$ \delta_{13}=\delta_{12}+\delta_{23}=\frac{T_{13}l_{D}}{A_{D}E} $$ $$ =\frac{(F_{2}-F_{1})l_{D}}{A_{D}E}+\frac{(F_{2}-F_{1})l_{C}}{A_{C}E} $$ $$ =\frac{(F_{2}-F_{1})}{E}\left( \frac{l_{D}}{A_{D}}+\frac{l_{C}}{A_{C}} \right) $$
  • Axiale Verschiebung des Stabes $A$:
  • $$ \delta_{34}=\frac{T_{34}l_{A}}{A_{A}E}=\frac{F_{2}l_{A}}{A_{A}E} $$
  • Gesamte axiale Verschiebung des Systems:
  • $$ \delta_{14}=\delta_{13}+\delta_{34} $$ $$ =\frac{(F_{2}-F_{1})}{E}\left( \frac{l_{D}}{A_{D}}+\frac{l_{C}}{A_{C}} \right) +\frac{F_{2}l_{A}}{A_{A}E} $$

In MATLAB wird die axiale Verschiebung der Stäbe und des Systems berechnet:

Untitled
delta_12=T_13*l_D/(A_D*E);
delta_23=T_13*l_C/(A_C*E);
delta_13=delta_12+delta_23;
delta_34=T_34*l_A/(A_A*E);
delta_14=delta_13+delta_34;
fprintf('delta_12 = %s \n',char(delta_12))
fprintf('delta_23 = %s \n',char(delta_23))
fprintf('delta_13 = %s \n',char(delta_13))
fprintf('delta_34 = %s \n',char(delta_34))
fprintf('delta_41 = %s \n\n',char(delta_14))

Numerische Lösung

Zur numerischen Berechnung der Axialspannungen und -verschiebungen werden zunächst die in der Aufgabenstellung angegebenen numerischen Daten in den MATLAB-Code eingegeben und dann die symbolischen Variablen durch die numerischen Daten ersetzt. Für den ersten Teil werden zwei Zell-Arrays eingeführt. Die String-Werte (die symbolischen Variablen) der numerischen Daten werden in Cell Array lists und ihre numerischen Werte in Cell Array listn eingetragen. Im zweiten Teil wird die symbolische Substitutionsfunktion subs von MATLAB verwendet, um die symbolischen Variablen in lists durch die entsprechenden Werte aus listn zu ersetzen, die dann auf dem Bildschirm angezeigt werden.

Untitled
%numerical application
lists={F_1,F_2,d,l_A,l_C,l_D, E};
listn={192000,64000,45,170,144.5,255,21*10^4};
F1n=subs(F_1,lists,listn);
F2n=subs(F_2,lists,listn);
T_13n=subs(T_13,lists,listn);
T_34n=subs(T_34,lists,listn);
fprintf('F1 = %s(N)\n', char(F1n))
fprintf('F2 = %s (N)\n', char(F2n))
fprintf('T_13 = %s (N)\n', char(T_13n))
fprintf('T_34 = %s (N)\n', char(T_34n))
fprintf('\n')

In ähnlicher Weise werden die numerischen Werte jedes Stabdurchmessers angezeigt und die Querschnittswerte mit Hilfe der MATLAB-Funktion eval berechnet und angezeigt:

Untitled
d_An=subs(d_A,lists,listn);
d_Cn=subs(d_C,lists,listn);
d_Dn=subs(d_D,lists,listn);
A_An=subs(A_A,lists,listn);
A_Cn=subs(A_C,lists,listn);
A_Dn=subs(A_D,lists,listn);
fprintf('d_A = %s (mm)\n',char(d_An))
fprintf('d_C = %s (mm)\n',char(d_Cn))
fprintf('d_D = %s (mm)\n',char(d_Dn))
fprintf('A_A = %s (mm^2)\n',eval(char(A_An)))
fprintf('A_C = %s (mm^2)\n',eval(char(A_Cn)))
fprintf('A_D = %s (mm^2)\n',eval(char(A_Dn)))
fprintf('\n')

Die numerischen Werte der einzelnen Stäbe werden in MATLAB durch ausgedrückt:

Untitled
l_An=subs(l_A,lists,listn);
l_Cn=subs(l_C,lists,listn);
l_Dn=subs(l_D,lists,listn);
fprintf('l_A = %s (mm)\n',char(l_An))
fprintf('l_C = %s (mm)\n',char(l_Cn))
fprintf('l_D = %s (mm)\n',char(l_Dn))
fprintf('\n')

Schließlich werden die numerischen Werte der Axialspannungen berechnet und in MATLAB dargestellt:

Untitled
sigma_An=subs(sigma_A,lists,listn);
sigma_Cn=subs(sigma_C,lists,listn);
sigma_Dn=subs(sigma_D,lists,listn);
fprintf('sigmA_A = %s (MPa)\n',eval(char(sigma_An)))
fprintf('sigmA_C = %s (MPa)\n',eval(char(sigma_Cn)))
fprintf('sigmA_D = %s (MPa)\n',eval(char(sigma_Dn)))
fprintf('\n')

und die Ergebnisse sind:

Untitled
sigma_A = 4.024066e+01 (MPa)
sigma_C = -8.048131e+01 (MPa)
sigma_D = -3.576947e+01 (MPa)

Die numerischen Werte für die axiale Verschiebung der Stäbe und des Systems werden in MATLAB berechnet:

Untitled
delta_12n=subs(delta_12,lists,listn);
delta_23n=subs(delta_23,lists,listn);
delta_13n=subs(delta_13,lists,listn);
delta_34n=subs(delta_34,lists,listn);
delta_14n=subs(delta_14,lists,listn);
delta_24n=delta_34n+delta_23n;
fprintf('delta_12 = %s (mm)\n',eval(char(delta_12n)))
fprintf('delta_14 = %s (mm)\n',eval(char(delta_14n)))
fprintf('delta_23 = %s (mm)\n',eval(char(delta_23n)))
fprintf('delta_34 = %s (mm)\n',eval(char(delta_34n)))
fprintf('delta_24 = %s (mm)\n',eval(char(delta_24n)))
fprintf('\n')

und die Ergebnisse sind:

Untitled
delta_12 = -4.343436e-02 (mm)
delta_14 = -6.623740e-02 (mm)
delta_23 = -5.537881e-02 (mm)
delta_34 = 3.257577e-02 (mm)
delta_24 = -2.280304e-02 (mm)

Diagramme

Die Kraft-, Spannungs- und Verschiebungsdiagramme (Abbildung 3) werden mithilfe des folgenden MATLAB-Codes erstellt:

Untitled
%Force Diagram
subplot(3,1,1)
ForceDdraw(T_13n,T_34n,l_An,l_Cn,l_Dn);
%Displacement Diagram
subplot(3,1,2)
DisplacementDdraw(delta_14n,delta_13n,...
delta_12n,l_An,l_Cn,l_Dn);
%Stress Diagram
subplot(3,1,3)
StressDdraw(sigma_An,sigma_Cn,...
sigma_Dn,l_An,l_Cn,l_Dn);

Figure 3
Abbildung 3: Kraft-, Spannungs- und Verschiebungsdiagramme

Zur Erstellung der Diagramme werden drei MATLAB-Funktionen verwendet, und zwar: ForceDdraw, StressDdraw und DisplacementDdraw, unter Verwendung der line-Funktion, die zwei Eingangsargumente benötigt. Diese Funktion zeichnet Linien in den aktuellen Achsen, indem sie die Daten in beiden Eingangsvektoren (oder Matrizen) verbindet. In diesem Fall sind beide Eingangsargumente Vektoren, wobei der erste Vektor die $x$-Koordinaten und der zweite Vektor die $y$-Koordinaten sind. Da beide Eingangsvektoren gleich lang sind, zeichnet die line-Funktion bei jeder Anwendung eine einzige Linie. Die Codes für die drei MATLAB-Funktionen sind wie folgt:

  • Die MATLAB-Funktion ForceDdraw:
  • Untitled
    function []=ForceDdraw(F1A,F2A,l1,l2,l3,l4)
    xlabel('Bar Length (mm)'), ylabel('Force (kN)')
    title('Force Diagram')
    hold on; grid on
    axis equal; axis on
    axis([-100 700 -200 200 ])
    hold on;
    scale_F=1000;
    hold on
    l=line([0 (l1+l2+l3)], [0 0]);
    l=line([(l1+l2+l3) (l1+l2+l3)], [0 F1A/scale_F]);
    l=line([(l1+l2+l3) (l1+l2+l3)-(l3)],...
    [F1A/scale_F F1A/scale_F]);
    l=line([(l1+l2+l3)-l3 (l1+l2+l3)-(l3)],...
    [F1A/scale_F F1A/scale_F]);
    l=line([(l1+l2+l3)-l3 (l1+l2+l3)-(l2+l3)],...
    [F1A/scale_F F1A/scale_F]);
    l=line([(l1+l2+l3)-(l2+l3) (l1+l2+l3)-(l2+l3)],...
    [F1A/scale_F F2A/scale_F]);
    l=line([0 (l1+l2+l3)-(l2+l3)],...
    [F2A/scale_F F2A/scale_F]);
    l=line([0 0], [F2A/scale_F 0]);
    set(l,'Color','blue');
    end

  • Die MATLAB-Funktion StressDdraw:
  • Untitled
    function []=StressDdraw(sigma1,sigma2,sigma3,l1,l2,l3)
    xlabel('Bar Length (mm)'), ylabel('Stress (MPa)')
    title('Stress Diagram')
    hold on; grid on
    axis equal; axis on
    axis([-100 700 -200 200])
    hold on;
    scale_S=1;
    hold on
    l=line([0 (l1+l2+l3)],[0 0]);
    l=line([(l1+l2+l3) (l1+l2+l3)],[0 sigma3]);
    l=line([(l1+l2+l3) (l1+l2+l3)-(l3)],...
    [sigma3/scale_S sigma3/scale_S]);
    l=line([(l1+l2+l3)-(l3) (l1+l2+l3)-(l3)],...
    [sigma3/scale_S sigma2/scale_S]);
    l=line([(l1+l2+l3)-(l3) (l1+l2+l3)-(l2+l3)],...
    [sigma2/scale_S sigma2/scale_S]);
    l=line([(l1+l2+l3)-(l2+l3) (l1+l2+l3)-(l2+l3)],...
    [sigma2/scale_S sigma1/scale_S]);
    l=line([0 (l1+l2+l3)-(l2+l3)],...
    [sigma1/scale_S sigma1/scale_S]);
    l=line([0 0],[sigma1/scale_S 0]);
    set(l,'Color','blue');
    end

  • Die MATLAB-Funktion DisplacementDdraw:
  • Untitled
    function []=DisplacementDdraw(delta1,delta2,delta3,l1,l2,l3)
    xlabel('Bar Length (mm)'), ylabel('Displacement (mm x 10^{-3})')
    title('Displacement Diagram')
    hold on; grid on
    axis equal; axis on
    axis([-100 700 -200 200])
    hold on;
    scale_D=10^(-3);
    hold on
    l=line([0 (l1+l2+l3)], [0 0]);
    l=line([(l1+l2+l3) (l1+l2+l3)-(l3)],...
    [0 delta3/scale_D]);
    l=line([(l1+l2+l3)-(l3) (l1+l2+l3)-(l2+l3)],...
    [delta3/scale_D delta2/scale_D]);
    l=line([(l1+l2+l3)-(l2+l3) (l1+l2+l3)-(l1+l2+l3)],...
    [delta2/scale_D delta1/scale_D]);
    l=line([0 0], [delta1/scale_D 0]);
    set(l,'Color','blue');
    end

AUFGABE 2: Biege- und Schubspannungen

Problembeschreibung

Ein Hebel $(1)$ der Länge $AC = l$ sitzt auf einem verjüngten Hebelstab $(2)$, bezeichnet mit $AB$. Der Hebel wird an seinem Ende mit einer horizontalen Kraft $F$ belastet, wie in Abbildung 4 dargestellt. Der Hebelstab hat den Radius $r$ und die Länge $d$.

Für die numerische Berechnung können die folgenden Werte verwendet werden:

  • $F = 250 \hspace{1pt} N$
  • $d = 200 \hspace{1pt} mm$
  • $l = 250 \hspace{1pt} mm$
  • $h = 50 \hspace{1pt} mm$
  • $r = 9 \hspace{1pt} mm$

Figure 4
Abbildung 4: Hebel unter Belastung

Projektziele

  • Bestimmung der Normal- und Schubspannungen eines Elements, das sich auf der freien Oberfläche des Hebelstabs $(2)$ im Abstand $h$ von der sechseckigen Basis befindet (das Element liegt parallel zu der durch die Achsen $x$, $y$ bestimmten Ebene).
  • Konstruktion des Mohrschen Spannungskreises und Bestimmung der Hauptebenen und Spannungen.

Lösung

Die Kraft $F$ bewirkt ein Biegemoment (reine Biegung) und ein Drehmoment (Torsionsmoment) auf den Stab. Durch die Biegung werden also Biegespannungen, die Normalspannungen sind, und über den Querschnitt verteilte Schubspannungen erzeugt.

Die Normal- und Schubspannungen eines allgemeinen Elements parallel zur Ebene, die durch die Achsen $x$, $y$ im Abstand $h$ von der hexagonalen Basis bestimmt wird, sind $\sigma_{y}$ bzw. $\tau_{yz}$.

Biegespannungen

$\sigma_{y}$ ist die Biegespannungsverteilung über die Biegehöhe, für den Fall der reinen Biegung:

\[\sigma_{y}(z)=\frac{M_{b,x}}{I_{x}}\cdot z\]

Die verschiedenen tiefgestellten Buchstaben drücken aus, dass die Biegespannung in $y$-Richtung über die hier durch die $z$-Koordinate definierte Biegehöhe verteilt wird, und $x$ ist die neutrale Achse.

  • $M_{b,x}$ ist das Biegemoment, es entspricht:
\[M_{b,x}=F\cdot (d-h)\]
  • $I_{x}$ ist das Flächenträgheitsmoment. Es ist eine geometrische Eigenschaft einer Form, die die Verteilung von Punkten um eine Achse beschreibt. In der klassischen Mechanik wird es als Maß für den Widerstand eines Körpers gegen Biegung verwendet. Für einen kreisförmigen Querschnitt ist es gleich:
\[I_{x} = \frac{\pi D^{4}}{64} = \frac{\pi r^{4}}{4}\]
  • Die Biegehöhe $z$ ist der senkrechte Abstand eines Punktes entlang des Querschnittes des Stabes von seiner neutralen Achse, und bei der Berechnung der maximalen Biegespannung ist $z$ gleich $r$, weil dort die Biegespannung entlang des Querschnittes ihren Höchstwert erreicht.

Die Gleichung für die Biegespannung zeigt, dass die Biegespannung linear zunimmt, wenn das Biegemoment und der Abstand von der neutralen Achse zunehmen, und dass sie abnimmt, wenn das Flächenträgheitsmoment zunimmt. Die maximale Spannung tritt an den am weitesten von der neutralen Achse entfernten Fasern auf. Der Term $\frac{z}{I_{x}}$ hängt nur von der Geometrie des Querschnitts ab.

Die maximale Biegespannung ist somit gleich:

\[\sigma_{y}=\frac{M_{b,x}}{I_{x}}\cdot r\]

Schubspannungen

Torsion ist die Verdrehung eines Objekts, die durch ein um die Längsachse des Objekts wirkendes Moment verursacht wird. Ein Moment, das die Tendenz hat, eine Verdrehung zu verursachen, wird als Drehmoment bezeichnet.

Die Torsion erzeugt Schubspannungen und -verformungen innerhalb des Stabes. Sowohl die Schubspannungen als auch die Schubverformungen nehmen linear mit dem Abstand von der Mitte des Querschnitts zu, wobei die maximale Schubspannung und Schubverformung an der Außenfläche auftritt.

Die maximale Schubspannung aufgrund von Torsion für einen kreisförmigen Querschnitt ist gegeben durch die Gleichung:

\[\tau = \frac{T_{y}\cdot r}{J_{p}}\]

Das heißt, die Schubspannung ist eine Funktion von

  • dem Drehmoment $T_{y}$, hier: um die $y$-Achse,
  • dem Abstand von der Mitte des Querschnitts, hier: gleich $r$; dem Abstand zum Rand,
  • und dem polaren Trägheitsmoment $J_{p}$.

Für einen kreisförmigen Querschnitt beträgt das polare Trägheitsmoment:

\[J_{p} = \frac{\pi \cdot r^{4}}{2}\]

Das Drehmoment $T_{y}= F \cdot l$.

\[\Rightarrow \tau = \frac{2F \cdot l}{\pi \cdot r^{3}}\]

** Spannungstransformation und Mohrscher Spannungskreis**

Betrachtet man ein 2D-Spannungselement, das einem ebenen Spannungszustand (z.B. der $xy$-Ebene) entspricht, so werden die vier Flächen des Elements durch Normal- und Schubspannungen beansprucht. Angenommen, dieses Element wird von einer schrägen Ebene mit einer Normalen in einem beliebigen Winkel $\phi$ gegen den Uhrzeigersinn von der $x$-Achse geschnitten, dann könnten die Werte der Normal- und Schubspannungen mit Hilfe der Spannungstransformationsgleichungen berechnet werden:

  • $\sigma = \frac{\sigma_{x}+\sigma_{y}}{2}+\frac{\sigma_{x}-\sigma_{y}}{2}\cdot cos(2\phi)+\tau_{xy}\cdot sin(2\phi)$
  • $\tau = \frac{\sigma_{x}-\sigma_{y}}{2}\cdot sin(2\phi)+\tau_{xy}\cdot cos(2\phi)$

Durch Differenzieren der ersten Gleichung nach $\phi$ und Gleichsetzen des Ergebnisses mit Null wird $\sigma$ maximiert und ergibt sich:

  • $tan(2\phi)=\frac{2\tau_{xy}}{\sigma_{x}-\sigma_{y}}$

Diese Gleichung definiert zwei bestimmte Werte für den Winkel $2\phi$, von denen einer die maximale Normalspannung $\sigma_{1}$ und der andere die minimale Normalspannung $\sigma_{2}$ definiert. Diese beiden Spannungen werden als Hauptspannungen bezeichnet, und ihre entsprechenden Richtungen als Hauptrichtungen. Der Winkel zwischen den beiden Hauptrichtungen ist $90°$. Diese Gleichung lässt sich aus der zweiten Gleichung der Spannungstransformationsgleichungen ableiten, indem $\tau =0$ gesetzt wird, was bedeutet, dass die senkrechten Flächen mit den Hauptspannungen keine Schubspannungen aufweisen.

Wichtig ist, dass die Winkel im Mohrschen Spannungskreis im Vergleich zum Drehwinkel des Spannungselements verdoppelt werden. Bei Betrachtung des Mohrschen Spannungskreises ergibt sich zum Beispiel ein Winkel von $180$ Grad zwischen der minimalen und der maximalen Hauptspannung, während der Winkel beim Spannungselement $90$ Grad beträgt. Aus diesem Grund wird auf dem Mohrschen Spannungskreis die Notation $2\phi$ verwendet. $\phi$ ist der Drehwinkel des Spannungselements, und $2\phi$ ist der entsprechende Winkel auf dem Mohrschen Spannungskreis.

Die Formeln für die beiden Hauptspannungen lassen sich durch Einsetzen des Winkels $2\phi$ in die erste Spannungstransformationsgleichung ermitteln:

  • $\sigma_{1}, \sigma_{2} =\frac{\sigma_{x}+\sigma_{y}}{2}\pm \sqrt{({\frac{\sigma_{x}-\sigma_{y}}{2})^{2}}+\tau_{xy}^{2}}$

In ähnlicher Weise erhält man durch Differenzieren der zweiten Spannungstransformationsgleichung nach $\phi$ und Gleichsetzen des Ergebnisses mit Null:

  • $tan(2\phi)=-\frac{\sigma_{x}-\sigma_{y}}{2\tau_{xy}}$

Damit sind die beiden Werte von $2\phi$ definiert, bei denen die Schubspannung $\tau$ einen extremen Wert (nicht das Maximum) erreicht. Der Winkel zwischen den beiden Flächen mit den maximalen Schubspannungen beträgt $90°$.

Die Formeln für die beiden extremen Schubspannungen werden durch den Einsatz des Winkels $2\phi$ in der zweiten Spannungstransformationsgleichung ermittelt:

  • $\tau_{1}, \tau_{2} =\pm \sqrt{({\frac{\sigma_{x}-\sigma_{y}}{2})^{2}}+\tau_{xy}^{2}}$

Analytische Lösung

Das MATLAB-Programm beginnt mit der Deklaration von Variablen als symbolische skalare Variablen mit Hilfe der syms-Funktion:

Untitled
clear; clc; close all
syms F l r d h phi

Anschließend werden die Normal- und Schubspannungen in MATLAB berechnet:

Untitled
I_x=pi*r^4/4; J_p=pi*r^4/2;
T_y=F*l;M_bx=F*(d-h);
sigma_x=0; sigma_y=M_bx*r/I_x;
tau=T_y*r/J_p;
fprintf('The normal and shear stress are \n');
fprintf('sigma_y = %s \n',char(sigma_y))
fprintf('tau = %s \n\n',char(tau))

Dies führt zu der folgenden Ausgabe:

Untitled
The normal and shear stress are
sigma_y = (4*F*(d - h))/(r^3*pi)
tau = (2*F*l)/(r^3*pi)

Anschließend werden die Elementorientierung und die Hauptspannungen in MATLAB berechnet:

Untitled
[sigma_max,sigma_min,radius,center_circle...
,phi,phi_p,sigma_phi,tau_phi]=...
mohr2D(sigma_x,sigma_y,tau,phi);
fprintf('The principal stress orientation is \n');
fprintf('tan(2*phi) = %s \n\n',char(phi_p))
fprintf('sigma_max = %s \n',char(sigma_max))
fprintf('sigma_min = %s \n',char(sigma_min))
fprintf('\n')

Dazu wird die vom Benutzer erstellte Funktion mohr2D(sigma_x,sigma_y,tau,phi) benötigt, um zu berechnen:

  • die maximale Normalspannung $\sigma_{1}$ (sigma_max) und die minimale Normalspannung $\sigma_{2}$ (sigma_min). Der Mohrsche Spannungskreis kreuzt die horizontale Achse an diesen beiden Stellen, da die Schubspannung Null ist. Diese beiden Werte können auch berechnet werden, indem man die $x$-Koordinate des Kreismittelpunkts nimmt und den Kreisradius addiert oder subtrahiert
  • der Radius (Radius) des Mohrschen Spannungskreises, der gleich $\sqrt{({\frac{\sigma_{x}-\sigma_{y}}{2})^{2}}+\tau_{xy}^{2}}$ ist, was auch der Wert der maximalen Schubspannung ist
  • der Mittelpunkt (Zentralkreis) des Mohrschen Spannungskreises, der bei $(\frac{\sigma_{x}+\sigma_{y}}{2},0)$ liegt
  • der Winkel $\phi$, im Code phi genannt, zwischen dem ursprünglichen Spannungselement und den Hauptebenen. $tan(2\phi)$ wird im Code als phi_p bezeichnet.

Diese Funktion wird durch den folgenden Code erzeugt:

Untitled
function [sigma_max,sigma_min,radius,...
center_circle,phi,phi_p,sigma_phi,tau_phi]=...
mohr2D(sigma_x,sigma_y,tau_xy,phi)
phi_p= 2*tau_xy/(sigma_x-sigma_y);
phi_radians= atan(phi_p)/2;
phi=(180*phi_radians)/(pi);
sigma_min=(sigma_x+sigma_y)/2-...
sqrt(((sigma_x-sigma_y)/2)^2+tau_xy^2);
sigma_max=(sigma_x+sigma_y)/2+...
sqrt(((sigma_x-sigma_y)/2)^2+tau_xy^2);
radius=sqrt(((sigma_x-sigma_y)/2)^2+tau_xy^2);
center_circle=(sigma_x+sigma_y)/2;
sigma_phi=(sigma_x+sigma_y)/2+...
((sigma_x-sigma_y)/2)*cos(2*phi)+...
tau_xy*sin(2*phi);
tau_phi=-((sigma_x-sigma_y)/2)*sin(2*phi)+...
tau_xy*cos(2*phi);
end

Und die Ausgabe dieses Codes ist:

Untitled
The principal stress orientation is
tan(2*phi) = -l/(d - h)
sigma_max = 2*((F^2*l^2)/(r^6*pi^2) + (F^2*(d - h)^2)/(r^6*pi^2))^(1/2) + (2*F*(d - h))/(r^3*pi)
sigma_min = (2*F*(d - h))/(r^3*pi) - 2*((F^2*l^2)/(r^6*pi^2) + (F^2*(d - h)^2)/(r^6*pi^2))^(1/2)

Numerische Lösung

Für die numerischen Berechnungen werden die numerischen Daten für die aufgebrachte Kraft $F$, die Länge des Hebels $l$, den Radius $r$ und die Länge $d$ des Hebelstabs sowie den Abstand $h$ des Elements auf dem Hebelstab in MATLAB als Eingabe eingegeben:

Untitled
%numerical application
lists={F,d,l,h,r};
listn={250,0.2,0.25,0.05,0.009};

Die numerischen Werte für das äquivalente Kräftesystem; Drehmoment $T_{y}$, Kraft $F$ und Biegemoment $M_{b,x}$, werden in MATLAB berechnet und ausgedruckt:

Untitled
T=subs(T_y,lists,listn);
F=subs(F,lists,listn);
M_bx=subs(M_bx,lists,listn);
fprintf('The equivalent force system is given by\n');
fprintf('T_y = %s (Nm)\n', char(T))
fprintf('F_h = %s (N)\n', char(F))
fprintf('M_bx = %s (Nm)\n\n', char(M_bx))

was zur Folge hatte:

Untitled
The equivalent force system is given by
T_y = 125/2 (Nm)
F_h = 250 (N)
M_bx = 75/2 (Nm)

Die numerischen Werte für die Spannungsausrichtung und die Hauptspannungen werden in MATLAB berechnet und angezeigt:

Untitled
%Mohr's circle
sigma_x=0;
sigma_y=eval(subs(sigma_y,lists,listn));
tau=eval(subs(tau,lists,listn));
sigma_max=eval(subs(sigma_max,lists,listn));
sigma_min=eval(subs(sigma_min,lists,listn));
radius=eval(subs(radius,lists,listn));
center_circle=eval(subs(center_circle,lists,listn));
phi=eval(subs(phi,lists,listn));
phi_p=eval(subs(phi_p,lists,listn));
fprintf('The principal stress orientation is \n');
fprintf('tan(2*phi) = %s \n', phi_p)
fprintf('or equivalently, \n')
fprintf('phi = %s degrees\n\n', phi)
fprintf('The principal stresses are \n');
fprintf('sigma_max = %f (MPa)\n', sigma_max*10^(-6))
fprintf('sigma_min = %f (MPa)\n', sigma_min*10^(-6))

was zur Folge hatte:

Untitled
The principal stress orientation is
tan(2*phi) = -1.666667e+00
or equivalently,
phi = -2.951812e+01 degrees
The principal stresses are
sigma_max = 96.398467 (MPa)
sigma_min = -30.902605 (MPa)

Grafische Darstellung

Die grafische Darstellung des Mohrschen Spannungskreises (Abbildung 5) wird in MATLAB durch Aufruf der benutzerdefinierten Funktion mohr2Ddraw erstellt:

Untitled
%Mohr's Circle Diagram
mohr2Ddraw(sigma_x,sigma_y,tau,...
sigma_max,sigma_min,center_circle,radius)

Figure 5
Abbildung 5: Mohrscher Spannungskreis

Der Code für die mohr2Ddraw Funktion ist:

Untitled
%Mohr's circle drawing
function [] = mohr2Ddraw(sigma_x,sigma_y,tau_xy,...
sigma_max,sigma_min,center_circle,radius)
xlabel('sigma [Pa]'), ylabel('tau [Pa]')
title('Mohr''s Circle')
hold on; grid on
axis equal; axis on
x_axis=quiver(center_circle-1.5*radius,0,...
center_circle+3*radius,0,...
'Color','b','LineWidth',1.0);
set(x_axis,'Color','black');
y_axis=quiver(0,-1.5*radius,0,3.5*radius,...
'Color','b','LineWidth',1.0);
set(y_axis,'Color','black');
plot(center_circle, 0, 'o','Color', 'red');
viscircles([center_circle,0],radius);
text(double(radius/15),double(radius/10),'O','fontsize',12)
text(double(2*radius),double(radius/7),'sigma','fontsize',12)
text(double(radius/10),double(1.5*radius),'tau','fontsize',12)
line([sigma_y sigma_x],[tau_xy -tau_xy], 'LineWidth', 2)
hold on
plot([sigma_x sigma_x],[-tau_xy 0],'--', 'LineWidth', 2)
hold on
plot([sigma_y sigma_y],[tau_xy 0],'--', 'LineWidth', 2)
plot(sigma_y,tau_xy, '+','Color', 'green', 'LineWidth', 2);
plot(sigma_x,-tau_xy, '+','Color', 'green', 'LineWidth', 2);
plot(sigma_max,0, '*','Color', 'yellow', 'LineWidth', 2);
plot(sigma_min,0, '*','Color', 'yellow', 'LineWidth', 2);
text(double(sigma_max),-double(radius/7),'sigma-max','fontsize',10)
text(double(sigma_min),-double(radius/7),'sigma-min','fontsize',10)
end

Aktualisiert: