Rob Siegwart - Engineering Design

Weld as a Line - Geometric Properties Table

2021-06-02T00:00:00-05:00

Properties

$s$ - weld size
$t$ - weld throat dimension, equal to $0.707s$ for typical fillet welds (joint angles between 80 and 100 degrees)
$d$ - height of weld shape
$b$ - width of weld shape
$A_u$ - unit weld area
$I_{u,x}$, $I_{u,y}$ - unit area moment of inertias, x-x and y-y axes, respectively
$J_u$ - Unit polar moment of inertia

Unit properties are defined in terms of unit weld size. Multiply their values by the throat dimension to obtain the actual value of the property, which is used in calculations when the weld size is known:

\begin{equation*} A = A_ut \end{equation*}

\begin{equation*} I_x = I_{u,x}t \qquad I_y = I_{u,y}t \end{equation*}

\begin{equation*} J = J_ut \end{equation*}

Table

Shape	$$ \bar{x} $$	$$ \bar{y} $$	$$ A_u $$	$$ I_{u,x} $$	$$ I_{u,y} $$	$$ J_u $$
Line	0	$$ \frac{d}{2} $$	$$ d $$	$$ \frac{d^3}{12} $$	$$ \frac{dt^3}{12} \text{*}$$	$$ \frac{d^3}{12} $$
Double Line	$$ b/2 $$	$$ d/2 $$	$$ 2d $$	$$ \frac{d^3}{6} $$	$$ \frac{db^2}{2} $$	$$ \frac{d(3b^2+d^2}{6} $$
L	$$ \frac{b^2}{2(b+d)} $$	$$ \frac{d^2}{2(b+d)} $$	$$ b+d $$	$$ \frac{d^3(d+4b)}{12(b+d)} $$	$$ \frac{b^3(d+4b)}{12(b+d)} $$	$$ \frac{b^4 + d^4 + 4bd(b^2+d^2)}{12(b+d)} $$
C	$$ \frac{b^2}{2b+d} $$	$$ \frac{d}{2} $$	$$ 2b+d $$	$$ \frac{d^2}{12}(d+6b) $$	$$ b^3\left( \frac{b+2d}{3(2b+d)} \right) $$	$$ \frac{d^2}{12}(d+6b) + b^3\left( \frac{b+2d}{3(2b+d)} \right) $$
Box	$$ \frac{b}{2} $$	$$ \frac{d}{2} $$	$$ 2(b+d) $$	$$ \frac{d^2}{6}(d+3b) $$	$$ \frac{b^2}{6}(b+3d) $$	$$ \frac{(b+d)^3}{6} $$
Circle	$$0$$	$$0$$	$$ 2\pi r $$	$$ \pi r^3 $$	$$ \pi r^3 $$	$$ 2\pi r^3 $$

* Typically not defined for this axis, but this allows one to compute a bending stress given a y-y moment.

References

Collins, Busby, Staab. Mechanical Design of Machine Elements and Machines. 2nd Ed.

Critical Tip Velocity

2021-05-16T00:00:00-05:00

The following describes an object moving at constant velocity and impacting a rigid obstacle, leading to pivoting and tip-over. The objective is to find the translational velocity that causes the object to rise to the "just-tipping" condition (maximal rise in height).

The equations are based on conservation of momentum and conservation of energy. The linear momentum is converted to an angular momentum by considering its moment arm about the pivot point. After impact, the angular momentum is converted from its initial value to zero at the "just tipping point". Energy is also conserved as the rotational kinetic energy is converted to potential energy.

Variables

$v_0$ - initial translational velocity
$H_O$ - angular momentum about pivot point O
$m$ - mass
$y$ - vertical distance from pivot point O to center of gravity
$I_O$ - moment of inertia about pivot point O
$KE$ - kinetic energy
$PE$ - potential energy
$g$ - gravitational acceleration constant
$h$ - CG height change
$\theta_0$ - resting angle between the CG vector relative to the pivot point and the horizontal plane
$\omega$ - rotational velocity

Equations

Translational momentum moment,

\begin{equation*} H = mv_0y \end{equation*}

Angular momentum,

\begin{equation*} H_O = I_O\omega \end{equation*}

Rotational kinetic energy,

\begin{equation*} KE = \frac{1}{2}I_O\omega^2 \end{equation*}

Potential energy,

\begin{equation*} PE = mgh \end{equation*}

Critical Tipping Velocity

The initial angular velocity, $\omega_0$, can be solved by equating the two momentum quantities.

\begin{equation*} H = H_O \end{equation*}

\begin{equation*} \omega_0 = \frac{mv_0y}{I_O} \end{equation*}

After impact, for the object to rise to the just-tipping point (maximum CG height change), the rotational kinetic energy is completely converted to potential energy:

\begin{equation*} \frac{1}{2}I_O\omega^2 = mgh \end{equation*}

\begin{equation*} \frac{1}{2}I_O \left( \frac{mv_0y}{I_O} \right)^2 = mgh \end{equation*}

Rearranging for the initial velocity, $v_0$:

\begin{equation*} v_0 = \sqrt{\frac{2ghI_O}{my^2}} \end{equation*}

Furthermore, the CG height change $h$ is known and can be expressed in terms of the rest angle, $\theta_0$:

\begin{equation*} h = r - r\sin\theta_0 = r(1-\sin\theta_0) \end{equation*}

$v_0$ then becomes:

\begin{equation*} v_0 = \sqrt{\frac{2gr(1-\sin\theta_0)I_O}{my^2}} \end{equation*}

Zero Gravity Hinges - An Analysis of Microsoft's Surface Studio Hinge

2019-07-22T00:00:00-05:00

Some time ago (2016), Microsoft released the Surface Studio accompanied by a great promo video. This product is an all-in-one computer featuring an adjustable display that maintains its position at any location set by the user. The hinge used with it - termed a "zero gravity" hinge - allows for this free positioning of the display and here we will attempt to analyze this type of design and determine how it works.

Design Notes

Without actually deconstructing one of these I am using images from the promo video and other publicly available information as reference.

Some observations:

The support arms are not independent - it is a 1 degree-of-freedom (DOF) system
Compression springs are used in the base and torsion springs are used in the display
A four-bar linkage is used in the support arms to connect the base to the display
This can be used to give the desired orientation response of the display by changing the lengths of the connecting members

This YouTube video confirms these observations.

Analysis

Overview

First we construct the overall layout and label relevant parts:

where,

\begin{equation*} m_s = \text{mass of support} \end{equation*}

\begin{equation*} m_d = \text{mass of display} \end{equation*}

At first glance,

At $B$, it appears that the moment needing resisted is only due to the display
At $A$, the moment due to the support arms and the display need resisted

However, since the linkage has only 1 DOF, the display would be supported (i.e. prevented from rotating) by applying a single moment anywhere along this chain such as at location $B$ or $A$. Thus, the moment due to the torsion spring in the display contributes to overall support of deadweight loads.

Mechanism

Based on screenshots from the above linked videos, there is a linkage (brown) internal to the two supporting arms that interfaces with compression springs in the base (purple). This linkage relates the orientation of the display with respect to the base.

Base Compression Springs

At Point A there are a total of four compression springs that act against a rocker arm (cyan). This provides a supporting moment at this joint. This moment is due to the offset height $h$ and the spring force $f_b=k_b\Delta l_b$. Here the moment varies non-linearly as the support arm is rotated since $h$ changes in addition to the spring force changing.

Using the following values and properties (estimates but actually tuned to give the best result - to see if this design could work), and the accompanying Python code, this results in a moment response curve as shown below.

\begin{equation*} r = 0.3 \text{ in} \end{equation*}

\begin{equation*} k_{b} = 4\times40 \text{ lbf/in} \end{equation*}

\begin{equation*} l_{free} = 2.5 \text{ in} \end{equation*}

# Nomenclature:
#   r         = base hinge moment arm length, inches
#   r_fb      = position vector of the base of the compression spring from the
#               pivot point (Point A)
#   k_b       = spring constant of the base compression spring, lbf/in
#   l_free    = free length of the base compression spring
#   start     = start of base hinge rotation, degrees
#   end       = end of base hinge rotation, degrees
#   r_a       = Pivot arm position vector
#   r_afb     = Spring direction vector
#   u_fb      = Spring direction unit vector
#   f_b       = Spring force vector
#   M         = Moment = r x F

r = 0.3
r_fb = np.array([1.53, 0.22, 0])
k_b = 4*40
l_free = 2.5
start = 0
end = 90

spring_M, thetas = [], []

for theta in range(start,end):
    theta_rad = np.radians(theta)
    r_a = np.array([r*np.cos(theta_rad), r*np.sin(theta_rad), 0])
    r_afb = r_a - r_fb
    u_fb = r_afb/np.linalg.norm(r_afb)
    f_b = np.dot(k_b*(l_free-np.linalg.norm(r_afb)),u_fb)
    M = np.cross(r_a,f_b)

    spring_M.append(M[2])
    thetas.append(theta)

fig1, ax1 = plt.subplots()
ax1.plot(thetas, spring_M, c='b', ls='dashed',
    label='Moment due to compression springs')
ax1.grid(True)
ax1.set_xlabel('Rotation, deg')
ax1.set_ylabel('Torque (Moment), in-lbs')

Torsion Spring

The moment due to the torsion spring is simply linear and dependent on the torsion spring stiffness. I am assuming and using some preload on this spring as I did with the compression spring.

The following properties are used and the resulting moments plotted.

k_d = 1.25                  # spring rate, lbf-in/deg
k_d_pre = 75                # Preload amount, lbs-in

tor_sp = []

for i in range(start,end):
    tor_sp.append(-k_d*i + k_d_pre)

fig2,ax2 = plt.subplots()
ax2.plot(thetas, tor_sp, '-.', c='g', label='Moment due to torsion spring')
ax2.plot(thetas, spring_M, c='b', label='Moment due to compression springs',
    ls='dashed')


# Add resisting moments of the compression springs and the torsion spring
combined = np.asarray(tor_sp) + spring_M
ax2.plot(thetas, combined, c='r', label='Combined moment')
ax2.grid(True)
ax2.legend()
ax2.set_xlabel('Rotation, deg')
ax2.set_ylabel('Torque (Moment), in-lbs')

Moment at the Base Hinge From Components Due to Gravity

Now, we calculate the loads due to deadweight. The two components involved are the display and the support arms. Each is assigned a weight:

\begin{equation*} m_d=10\text{ lbs} \end{equation*}

\begin{equation*} m_s=4\text{ lbs, both arms} \end{equation*}

To assess if the display will be supported (or if it will fall or rise), we compare the resisting moments due to the springs to the total deadweight moment. The total deadweight moment is the resultant moment of each of the contributing moments of the display and support arms. Maintaining the display position in any configuration requires that the resisting moments and load moments be exactly equal; though small amounts of difference can be taken up through friction by the system connecting components.

Calculating the deadweight moment requires analysis of the support arm linkage. As an approximation of this we can infer the positions of the support arms and display graphically using the following screenshots:

The center of gravities are taken at the midpoint of both the support arms and display. This allows the combined moment to be estimated:

from scipy.interpolate import interp1d

# Measurement based approach - infer linkage from screenshot measurements
r_d = 3.9              # distance from display pivot point to display CG, inches
r_s = 4.0              # distance from base pivot to support arms CG, inches

m_s = 3.75             # mass of support arms, lbs
m_d = 10               # mass of display, lbs

M_dw = []              # deadweight total moment, in-lbs

# support arm and display angle measurements
disp_rot = interp1d([5.2,14.4,34.4,52.8],[142.7,132.2,115.9,96],
    kind='quadratic')
t2 = []

for theta in np.linspace(min(disp_rot.x),max(disp_rot.x),20):
    theta_rad = np.radians(theta)
    M_dw.append(
        m_s*r_s*np.cos(theta_rad)
        + m_d*(2*r_s*np.cos(theta_rad)
        + r_d*np.cos(np.radians(disp_rot(theta)))) )
    t2.append(theta)

fig3,ax3 = plt.subplots()
ax3.plot(t2, M_dw, c='black', lw=3, label='Deadweight moment')
ax3.set_title('Moment Due to Deadweight')
ax3.set_ylabel('Moment, in-lbs')
ax3.set_xlabel('Base hinge rotation, degrees')
ax3.grid(True)
ax3.legend()
fig3.savefig('fig3.png',dpi=200)

# Make a composite final figure
fig4,ax4 = plt.subplots()
ax4.plot(thetas, combined, c='r', label='Combined supporting moment')
ax4.plot(thetas, tor_sp, '-.', c='g', label='Moment due to torsion spring')
ax4.plot(thetas, spring_M, c='b', ls='dashed',
    label='Moment due to compression springs')
ax4.plot(t2, M_dw, c='black', lw=3, label='Deadweight moment')
ax4.set_ylabel('Moment, in-lbs')
ax4.set_xlabel('Base hinge rotation, degrees')
ax4.grid(True)
ax4.legend()

Moment Summary

Finally, plotting the combined moment with the deadweight moment shows reasonable agreement. More accurate properties - component weights and CG's, in addition to spring properties - would allow for better correlation but the concept confirms that this configuration can result in the desired behavior.

Conclusions

The configuration of springs and linkages show that equal (or near equal) moments are developed to create static equilibrium
- Friction between components could take up small differences in loads or provide for some support for the user
Tuning is accomplished primarily by selection of spring stiffenesses, spring preload amounts (i.e. the load at resting positions), length of the base hinge rocker arm, and potentially also by adjusting the weight and CG of the computer components (though less desirable than adjusting spring parameters)

Interpolating Logarithmic Plots for Fatigue Analysis

2019-01-23T00:00:00-06:00

Here we will develop some classes for interpolating general multi-linear fatigue curves using SciPy's interp1d. interp1d creates a class instance which can then be called with lookup values:

x = [ 1,2,3,...]      # X-axis values
y = [ 20,15,10,...]   # Y-axis values
f = interp1d(x,y)
y1 = f(x1)            # Query at a new value, x1

Semi-Log

Using a linear interpolation function on a semi-log graph requires that the log of the values is used on the log axis. With fatigue curve arrays of $N$ and $S$, interpolating for stress can be done by:

\begin{equation*} f=\text{interp1d}(\log_{10}N, S) \end{equation*}

\begin{equation*} S_{new}=f(\log_{10}N_{new}) \end{equation*}

And interpolating for cycles:

\begin{equation*} f=\text{interp1d}(S, \log_{10}N) \end{equation*}

\begin{equation*} N_{new}=10^{f(S_{new})} \end{equation*}

Log-Log

Log-log calculations are the same as Semi-log but with the exception that both axes use the logarithm of the values.

To obtain stress:

\begin{equation*} f=\text{interp1d}(\log_{10}N, \log_{10}S) \end{equation*}

\begin{equation*} S_{new}=10^{f(\log_{10}N_{new})} \end{equation*}

To obtain cycles:

\begin{equation*} f=\text{interp1d}(\log_{10}S, \log_{10}N) \end{equation*}

\begin{equation*} N_{new}=10^{f(\log_{10}S_{new})} \end{equation*}

Implementation

In Python we can implement the above as classes. First a general class common to both log-log and semi-log:

import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import interp1d

class FatigueCurve:
    ''' Base class for a fatigue curve.

        Parameters
        ----------
        points : list
            A list containing (N,S) data point pairs (2+)

    '''
    def __init__(self,points):
        self.N, self.S = list(zip(*points))
        self.N = np.asarray(self.N)
        self.S = np.asarray(self.S)
        self.logN = np.log10(self.N)
        self.logS = np.log10(self.S)

    def _plot(self):
        ''' Plot setup method '''
        fig, ax = plt.subplots()
        ax.set_xlabel('Cycles')
        ax.set_ylabel('Stress')
        ax.grid(True, which='both', axis='both', color='lightgrey')
        return fig, ax

Next we create classes for semi-log and log-log:

class SemiLogCurve(FatigueCurve):
    def __init__(self,points):
        super().__init__(points)
        self.getS_f = interp1d(self.logN,self.S)
        self.getN_f = interp1d(self.S,self.logN)

    def _semilogx(self,ax,N,S):
        ''' Plot an interpolated value on a semilog fatigue curve. '''
        ax.semilogx(self.N,self.S,markersize=6,marker='o')
        ax.semilogx(N,S,markersize=6,marker='o')
        ax.annotate('({:,.2}, {:,.2})'.format(N,S), (N,S))
        return ax

    def getS(self,N,plot=False):
        ''' Interpolate stress from cycles. '''
        S = self.getS_f(np.log10(N))
        if plot:
            fig,ax = self._plot()
            ax = self._semilogx(ax,float(N),float(S))
        return int(S)

    def getN(self,S,plot=False):
        ''' Interpolate cycles from stress. '''
        N = np.power(10,self.getN_f(S))
        if plot:
            fig,ax = self._plot()
            ax = self._semilogx(ax,float(N),float(S))
        return int(N)

    def plot(self):
        fig, ax = self._plot()
        ax.semilogx(self.N,self.S)

    __call__ = getS


class LogLogCurve(FatigueCurve):
    def __init__(self,points):
        super().__init__(points)
        self.getS_f = interp1d(self.logN,self.logS)
        self.getN_f = interp1d(self.logS,self.logN)

    def _loglog(self,ax,N,S):
        ''' Plot an interpolated value on a log-log fatigue curve. '''
        ax.loglog(self.N,self.S,marker='o',markersize=6)
        ax.loglog(N,S,marker='o',markersize=6)
        ax.annotate('({:,.2}, {:,.2})'.format(N,S), (N,S))
        return ax

    def getS(self,N,plot=False):
        ''' Interpolate stress from cycles '''
        S = np.power(10,self.getS_f(np.log10(N)))
        if plot:
            fig,ax = self._plot()
            ax = self._loglog(ax,float(N),float(S))
        return int(S)

    def getN(self,S,plot=False):
        ''' Interpolate cycles from stress '''
        N = np.power(10,self.getN_f(np.log10(S)))
        if plot:
            fig,ax = self._plot()
            ax = self._loglog(ax,float(N),float(S))
        return int(N)

    def plot(self):
        fig, ax = self._plot()
        ax.loglog(self.N,self.S)

    __call__ = getS

Usage

>>> curve = LogLogCurve([(1e3,50e3),(1e6,20e3),(1e7,18e3)])
>>> curve.getS(70e3,plot=True)
28459

>>> curve.getN(34e3,plot=True)
18309

Failure Theories

2015-10-06T00:00:00-05:00

For part stresses that are multi-axial, failure theories relate the failure in a part subjected to arbitrary multi-axial loads to that of a uni-axially loaded test specimen. The general form of these relationships are:

\begin{equation*} M_{part}\geq M_{specimen} \end{equation*}

Where M is a “modulus” chosen by each theory that can be either calculated or measured in the part and test specimen, and then compared to assess failure. Often the modulus is a function of the principal normal or shear stresses.

\begin{equation*} f(\sigma_1,\sigma_2,\sigma_3)\geq \sigma_c \end{equation*}

\begin{equation*} f(\tau_1,\tau_2,\tau_3)\geq \tau_c \end{equation*}

where $\sigma_c$ and $\tau_c$ are the chosen characteristic failure strengths from the uniaxial tension test.

The major theories are:

Maximum Normal Stress Theory

Failure (i.e. yielding, fracture) is expected to occur if the maximum normal stress in the part exceeds the maximum normal stress in test specimen at failure (yielding, fracture).

\begin{equation*} \max(\sigma_1,\sigma_2, \sigma_3)\geq \sigma_c \end{equation*}

\begin{equation*} \min(\sigma_1,\sigma_2,\sigma_3) \leq \sigma_c \end{equation*}

where $\sigma_t$ and $\sigma_c$ are test specimen tensile and compressive strengths, respectively.

This theory is applicable to brittle materials but not to ductile materials.

Maximum Shearing Stress Theory

Here failure is predicted to occur if the maximum shearing stress (the principal shearing stress) is equal to or exceeds the maximum shear stress in a test specimen at failure.

\begin{equation*} \max(|\tau_1|, |\tau_2|, |\tau_3|) \geq \tau_c \end{equation*}

$\tau_c$ is the maximum shearing stress in the test specimen, and for a uniaxial tension test the max shear stress occurs at 45 degrees to the applied load direction and is equal to half of the first principal stress, which is the nominal tensile stress.

This theory applies well to ductile materials and to ductile yielding.

Distortion Energy Theory (von Mises)

This theory postulates that the distortion energy - that which contributes to shape change and not to change in volume - affects the failure of the part. Dilation energy, that which only changes the volume, does not contribute to the failure of the part. The latter is produced by hydrostatic stress, which has been shown to not induce yielding or fracture (none under compression, but fracture under high levels of tensile stress).

The equation for the distortion energy theorem is:

\begin{equation*} \frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2} \geq \sigma_f^2 \end{equation*}

The left side of the equation when (sigma_f) is solved is the von Mises stress:

\begin{equation*} \sigma_{vm} = \sqrt{\frac{(\sigma_1-\sigma_2)^2 + (\sigma_2-\sigma_3)^2 + (\sigma_3-\sigma_1)^2}{2}} \end{equation*}

The yield and failure surface can be plotted, obtaining an infinite cylinder. According to the theory all stress points that lie within the surface do not produce failure and those outside do.

For a 2D stress state, the yield surface produces an elliptical failure curve when intersected with a plane.

This can be verified by setting $\sigma_3$ equal to 0 and plotting. With a constant of 1:

Principal Stresses in 3D

2015-09-14T00:00:00-05:00

When a stress element is characterized by its six stress components and these components are put in stress tensor form, the principal normal stresses are simply the eigenvalues of the stress tensor, and the principal planes are defined by the eigenvectors. This is easily computed using a mathematical program such as MathCAD, Matlab, etc. Here we will use Python and the library NumPy.

Principal Normal Stress

Put the stresses into the stress tensor form:

\begin{equation*} S=\begin{bmatrix}\sigma_x & \tau_{xy} & \tau_{zx} \\ \tau_{xy} & \sigma_y & \tau_{yz} \\ \tau_{zx} & \tau_{yz} & \sigma_z \end{bmatrix} \end{equation*}

import numpy as np
S = np.array([ [S_xx, S_xy, S_zx],
               [S_xy, S_yy, S_yz],
               [S_zx, S_yz, S_zz] ])

Then, compute the eigenvalues and eigenvectors. In Python:

e_val, e_vec = np.linalg.eig(S)

To store the eigenvalues in the variable e_val and the eigenvectors in the variable $e_vec$.

The principal stresses can be assigned by sorting, based on the assignment relation of $\sigma_1 > \sigma_2 > \sigma_3$.

p3, p2, p1 = np.sort(e_val)   # sort smallest to largest

The eigenvectors are stored as column vectors in the e_vec array. To access these, we first need to associate the principal stresses with their positions in the original result in order to assign them the correct vector. To do this we will convert the original eigenvalue array to a regular list and use standard Python indexing. Then, the vectors are extracted from the eigenvector array using these indices.

e_val_l = e_val.tolist()
p1_index, p2_index, p3_index = e_val_l.index(p1), e_val_l.index(p2), e_val_l.index(p3)
p1_vec, p2_vec, p3_vec = e_vec[:,p1_index], e_vec[:,p2_index], e_vec[:,p3_index]

Principal Shear Stress

The principal shearing stresses can be inferred from the usage of a Mohr circle. In constructing a Mohr circle for a 3D stress state, the maximum shearing stress can be shown to be one half of the difference between the maximum and minimum principal normal stresses. From the Mohr circle the principal shearing stresses can be determined as:

\begin{align*} \tau_1=(\sigma_1-\sigma_3)/2 \\ \tau_2=(\sigma_1-\sigma_2)/2 \\ \tau_3=(\sigma_2-\sigma_3)/2 \end{align*}

In Python,

tau1 = (p1-p3)/2
tau2 = (p1-p2)/2
tau3 = (p2-p3)/2

The principal shearing planes bisect the two principal normal planes used in determining the principal shearing stress. The $\tau_1$ plane bisects the $\sigma_1$ and $\sigma_3$ planes, and since all principal normal planes are orthogonal to each other, the principal shearing planes are at 45 degrees to each principal normal plane.

To find the vectors for these planes, we compute the vector that bisects the vectors for the normal principal stresses. Add them vectorally to obtain a rhombus, the diagonal of which splits the rhombus into two equal segments.

In Python we add our normal principal vectors and divide by the magnitude to normalize:

tau1_vec = (p1_vec + p3_vec)/np.linalg.norm(p1_vec + p3_vec)
tau2_vec = (p1_vec + p2_vec)/np.linalg.norm(p1_vec + p2_vec)
tau3_vec = (p2_vec + p3_vec)/np.linalg.norm(p2_vec + p3_vec)