Front Suspension

Mechanical Systems Model of a Transverse-Shock, Anti-roll Automotive Front Suspension

by Robert Beretta

Suspension Graphic

Reference

Context   
Mech`Mech3D`   
Package Version   
1.3
Mathematica Version   
2.2
Copyright   
Copyright 1996, Dynamic Modeling

Discussion

Suspension Function

This notebook describes the motion of a pull-rod, inboard damper automotive front suspension system.  The suspension system is analyzed to show how changes in the linkage geometry affect the velocity ratio between wheel and damper motion. A static force analysis is done to determine the loads on each of the elements of the suspension linkage.

The pull-rod front suspension mechanism is a rising-rate, inboard damper automotive suspension system that has inherent anti-roll characteristics. Function is as follows:   

The wheel carrier is primarily attached to the chassis by a classic double A-arm. A primary tie rod attaches to the top of the wheel carrier and extends downward toward the center and bottom of the car, such that it is in tension when supporting the weight of the car. This tie rod is attached to the rocker arm, which is forced to pivot about its axis on the chassis as the suspension travels. 

As the rocker arm pivots it pulls on the secondary tie rod, which passes from the rocker arm across the bottom of the car to the toggle. Thus, the right-hand wheel directly actuates the left toggle, and vice-versa. 

The two damper-spring assemblies (shocks absorbers) lie horizontally across the bottom of the vehicle, one in front of the other. Thus, the suspension is asymmetrical in the vehicle, although its operation is symmetrical with respect to the compression of the shocks relative to wheel travel. Each of the two shocks attaches to both of the toggles, being controlled simultaneously from both ends. If one wheel were to go over a bump, while the other stayed still, the rotation of the toggle attached to that wheel would cause one of the two shocks to be compressed, and the other shock to be released.

The unique anti-roll characteristics of this suspension system can be described qualitatively as follows:   

Imagine that the end of each toggle that compresses the shock is 3 times longer than the end that releases the shock. The vehicle then goes over a bump that moves both wheels upward simultaneously 1 unit of travel. Call it a 1 unit bump. The compression end of each toggle compresses its shock 3 units, while the release end of each toggle releases its shock 1 unit. This results in a net compression of each shock of two units. 

Now imagine that the vehicle is rolling in a corner such that the right wheel travels upward 1 unit, and the left wheel travels downward 1 unit. The toggle associated with the right wheel compresses its shock 3 units, while the toggle associated with the left wheel compresses the same shock 1 more unit, for a total compression of 4 units. Similarly, the other shock is released 4 units by the chassis roll. 

To summarize, a 3:1 ratio between the length of the compression and release ends of the toggles results in effective suspension stiffness that is two times greater in pure roll than in pure bump. The magnification of the anti-roll characteristic is adjusted simply by changing the ratio of the lengths of the two ends of the toggles.

Suspension Model

Bodies

The Mech3D model of the inboard damper suspension consists of eight bodies, five of them moving:   
    1.  The ground;  this body serves as the stationary reference frame for the entire model. 
    2.  The chassis   
    3.  The right carrier;  since the wheel does not need to spin in this model, this single body serves as both the right wheel and right wheel carrier (the king pin). 
    4.  The left carrier; this body serves as the left wheel and left wheel carrier. 
    5.  The right rocker;  the rocker arm that links the two tie rods for the right suspension. 
    6.  The left rocker; the rocker arm that links the two tie rods for the left suspension. 
    7.  The left toggle;  the final rocker arm that ties the motion of the right wheel to its shock. 
    8.  The right toggle;  the final rocker arm that links the motion of the left wheel to its shock.

Coordinates

The 3D coordinate system of the model is as follows.
+X is out the back of the vehicle
+Y is out the right side of the vehicle
+Z is straight up

The origin of the global coordinate system is located on the surface of the ground (Z), at the center of the car (Y), and directly between the centers of the two front wheels (X). All units are assumed to be in inches. The overall physical scale of the model is that of a 3/4 scale Formula one Car.

Kinematic Model

Preparation

This loads the required Mech3D package into Mathematica.

Needs["Mech`Dyna3D`"]

Names are defined for each of the body numbers for clarity.

ground = 1;
chassis = 2;
rightcarrier = 3;
leftcarrier = 4;
rightrocker = 5;
leftrocker = 6;
righttoggle = 7;
lefttoggle = 8;

Body Definitions

The Ground

Two points are defined on the ground body:   
   P1.  A point directly above the origin (+Z direction) to define a vertical translation axis for the chassis. 
   P2.  A point directly to the right side of the origin (+Y direction) to use as a rotational orientation reference for the chassis.

bd[ground] = 
        Body[ground, 
          PointList -> {  {0, 0, 10},   {0, 10, 0}}];

The Chassis

The local origin of the chassis is located at the bottom surface of the chassis, at the center of the car, directly below the wheel axis. Thus, the origin of the chassis is coincident with the origin of the ground when the car's suspension is bottomed out. 

Sixteen points are defined on the chassis.
P1.  The center of rotation of the right upper A-arm on the chassis. The upper ball joint on the right wheel carrier travels on a circular path centered at this point.
P2 and P3.  The two attachment points of the right upper A-arm on the chassis. These are immediately in front of and behind point P1. 
P4.  The center of rotation of the left upper A-arm on the chassis. This point is mirrored from point 1 across the plane normal to the local Y axis. 
P5 and P6.  The two attachment points of the left upper A-arm on the chassis. These are immediately in front of and behind P4.
P7.  The center of rotation of the right lower A-arm on the chassis. The lower ball joint on the right wheel carrier travels on a circular path centered at this point.
P8 and P9.  The two attachment points of the right lower A-arm on the chassis. These are immediately in front of and behind P7. 
P10.  The center of rotation of the left lower A-arm on the chassis. This point is mirrored from P7. 
P11 and P12.  The two attachment points of the left lower A-arm on the chassis. These are immediately in front of and behind P10.
P13.  A point on the pivot axis of the right rocker on the chassis. 
P14.  A point on the pivot axis of the left rocker on the chassis. 
P15.  A point on the pivot axis of the right toggle on the chassis. The Z coordinate of this point sets the height of the center-line of the right toggle.
P16.  A point on the pivot axis of the left toggle on the chassis. 

The InitialGuess for the chassis corresponds to the chassis being 1.5" off of the ground (normal ride height). Only the mass of the chassis is included in this model, because the masses of the other components are negligible.

bd[chassis] = 
        Body[chassis, 
          PointList -> 
            {  a = {0, 12.453, 12.125},   a + {-7, 0, 0},  
                 a + {7, 0, 0},   b = a {1, -1, 1},   
                b + {-7, 0, 0},   b + {7, 0, 0},   a = 
                {0, 9.5, 4.35},   a + {-7, 0, 0},   a + 
                {7, 0, 0},   b = a {1, -1, 1},   b + 
                {-7, 0, 0},   b + {7, 0, 0},   a = 
                {0.0, 9.5, 3.75},   a {-1, -1, 1},   b 
                = {1.063, 5.985, 0.516},   b {-1, -1, 1}}, 
          InitialGuess -> {{0, 0, 1.5}, {1, 0, 0, 0}}, Mass -> 0.5, 
          Centroid -> {0, 0, 7}];

The Right and Left Carriers

The local origins of the two wheel carriers are at the attachment points of the lower A-arms. 

Four points are defined on each wheel carrier:   
    P1.  The attachment point of the upper A-arm on the carrier.
    P2 and P3.  Two points that define the ends of the axle on the wheel carrier. 
    P4.  A point at the bottom of the tire, where the tire touches the ground. This point is used to constrain that the bottom of the tire to be in contact with the ground. 

The points on the left wheel carrier are a mirror of the points on the right wheel carrier, mirrored across the local Y plane relative to the right wheel carrier.

bd[rightcarrier] = 
        Body[rightcarrier, 
          PointList -> 
            (a = {  {0, -0.5, 9.5},   {0, -0.243, 
                    4.625},   {0, 1.283, 4.625},   {0, 1.283, 
                    -5.375}}), 
          InitialGuess -> {{0, 24.7, 5.375}, {1, 0, 0, 0}}];

bd[leftcarrier] = 
        Body[leftcarrier, 
          PointList -> 
            a . {  {1, 0, 0},   {0, -1, 0},   {0, 0, 
                  1}}, InitialGuess -> 
            {{0, -24.7, 5.375}, {1, 0, 0, 0}}];

Right and Left Rockers

The local origins of the rockers are located at the points where they attach to the chassis. 

Two points are defined on the each of the two rockers:   
    P1.  The attachment point of the upper tie rod on the rocker. 
    P2.  The attachment point of the lower tie rod on the rocker.

The left rocker is a mirror of the right rocker.

bd[rightrocker] = 
        Body[rightrocker, 
          PointList -> 
            (a = {  {0,  .9339 RockerLength, 
                    - .3574 RockerLength},   {0, -0.784, 
                    -3.154}}), 
          InitialGuess -> {{0, 9.5, 5.25}, {1, 0, 0, 0}}];

bd[leftrocker] = 
        Body[leftrocker, 
          PointList -> 
            a . {  {1, 0, 0},   {0, -1, 0},   {0, 0, 
                  1}}, InitialGuess -> 
            {{0, -9.5, 5.25}, {1, 0, 0, 0}}];

SetParameters is used to set the value of a constant in the model; in this case the value of RockerLength.

SetParameters[RockerLength -> 3];

The Right and Left Toggles

The local origins of the toggles are located at the points where they attach to the chassis. 

Three points are defined on each toggle:   
    P1.  The attachment point of the shock absorber that is extended during bump.
    P2.  The attachment point of the lower tie rod on the toggle. 
    P3.  The attachment point of the shock absorber that is compressed during bump.

The left toggle is a mirror of the right toggle.

bd[righttoggle] = 
        Body[righttoggle, 
          PointList -> 
            (a = {  {ToggleLength, 0, 0},   {-2, 0, 0},  
                     {-4.5, 0, 0}}), 
          InitialGuess -> {{1.063, 5.985, 2.016}, {1, 0, 0, 0}}];

bd[lefttoggle] = 
        Body[lefttoggle, 
          PointList -> 
            a . {  {-1, 0, 0},   {0, -1, 0},   {0, 
                  0, 1}}, 
          InitialGuess -> 
            {{-1.063, -5.985, 2.016}, {1, 0, 0, 0}}];

SetParameters[ToggleLength -> 1.5];

Incorporate the Body Objects into the Model

SetBodies[bd[ground], bd[chassis], bd[rightcarrier], bd[leftcarrier], 
      bd[rightrocker], bd[leftrocker], bd[righttoggle], bd[lefttoggle]]

Constraint Definitions

Constraints for the Chassis

1.A translational joint that allows the chassis to translate on a plane that is normal to the global X axis.
2. A relative Y constraint controls the side-to-side position of the car. 
3. A relative Z constraint to set the height of the chassis by specifying the Z component of the origin of the chassis. Positive T causes the car to move towards the ground, T = 0 is equal to 1.5 inch ride height. 
4. A relative angle constraint controls the roll of the car. Positive T causes the car to roll to the left. 

Driving constraints 3 and 4 can be turned "on and off" by setting the values of Roll and Bounce equal to 0 or 1.

cs[1] = 
        PlaneToPlane3[1, Plane[ground, 0, 1, 2], 
          Plane[chassis, 0, {0, 0, 1}, {0, 1, 0}]];
cs[2] = RelativeY1[2, Centroid[chassis], 0];
cs[3] = RelativeZ1[3, Point[chassis, 0], 1.5 - Bounce T];
cs[4] = 
        RelativeAngle1[4, Line[chassis, 0, {0, 0, 1}], 
          Line[ground, 0, {0, 1, 0}], π/2.0 + Roll T];

SetParameters[Bounce -> 1, Roll -> 0];

Constraints for the Right and Left Carriers

5.  A constraint to model the right upper A-arm. Two degrees of freedom constrained.
6.  A constraint to model the right lower A-arm. Two degrees of freedom constrained.
7.  A constraint to set the steering angle of the right wheel by controlling the included angle between the axle and a fore-aft line on the ground. One degrees of freedom constrained.
8.  A constraint to place the bottom of the right tire on the surface of the road. One degrees of freedom constrained.

Constraints 9, 10, 11, and 12 control the left wheel carrier in a similar fashion.

cs[5] = 
        PointOnCircle2[5, Point[rightcarrier, 1], Line[chassis, 1, 2], 
          UpperArmLength];
cs[6] = 
        PointOnCircle2[6, Point[rightcarrier, 0], Line[chassis, 7, 8], 
          LowerArmLength];
cs[7] = 
        RelativeAngle1[7, Line[rightcarrier, 2, 3], 
          Vector[ground, {1, 0, 0}], SteerAngle];
cs[8] = RelativeZ1[8, Point[rightcarrier, 4], 0];
cs[9] = 
        PointOnCircle2[9, Point[leftcarrier, 1], Line[chassis, 4, 5], 
          UpperArmLength];
cs[10] = 
        PointOnCircle2[10, Point[leftcarrier, 0], Line[chassis, 10, 11], 
          LowerArmLength];
cs[11] = 
        RelativeAngle1[11, Line[leftcarrier, 2, 3], 
          Vector[ground, {-1, 0, 0}], SteerAngle];
cs[12] = RelativeZ1[12, Point[leftcarrier, 4], 0];

SetParameters[SteerAngle -> π/2.0, 
        UpperArmLength -> 11.814, LowerArmLength -> 15.207];

Constraints for the Right and Left Rockers

13.  A revolute constraint to model the pivot axis of the right rocker. Five degree of freedom constrained.
14.  A constraint to model the right upper right tie rod. One degrees of freedom constrained.
15.  A revolute constraint to model the pivot axis of the left rocker. Five degree of freedom constrained.
16.  A constraint to model the left upper left tie rod. One degrees of freedom constrained.

cs[13] = 
        Revolute5[13, Axis[chassis, 13, {1, 0, 0}], 
          Line[rightrocker, 0, {1, 0, 0}]];
cs[14] = 
        RelativeDistance1[14, Point[rightrocker, 1], Point[rightcarrier, 1], 
          UpperTieRodLen];
cs[15] = 
        Revolute5[15, Axis[chassis, 14, {1, 0, 0}], 
          Line[leftrocker, 0, {1, 0, 0}]];
cs[16] = 
        RelativeDistance1[16, Point[leftrocker, 1], Point[leftcarrier, 1], 
          UpperTieRodLen];

SetParameters[UpperTieRodLen -> 16];

Constraints for the Left and Right Toggles

17.  A constraint to model the lower right tie rod. One degree of freedom constrained.
18.  A revolute constraint to model the pivot axis of the left toggle. Five degrees of freedom constrained.
19.  A constraint to model the lower left tie rod. One degree of freedom constrained.
20.  A revolute constraint to model the pivot axis of the left toggle. Five degrees of freedom constrained.

cs[17] = 
        RelativeDistance1[17, Point[rightrocker, 2], Point[lefttoggle, 2], 
          LowerTieRodLen];
cs[18] = 
        Revolute5[18, Axis[chassis, 16, {0, 0, 1}], 
          Line[lefttoggle, 0, {0, 0, 1}]];
cs[19] = 
        RelativeDistance1[19, Point[leftrocker, 2], Point[righttoggle, 2], 
          LowerTieRodLen];
cs[20] = 
        Revolute5[20, Axis[chassis, 15, {0, 0, 1}], 
          Line[righttoggle, 0, {0, 0, 1}]];

SetParameters[LowerTieRodLen -> 14.9];

Incorporate the Constraint Objects into the Model with SetConstraints

Any subset of the entire set of defined constraints may be used, so long as the set adequately constrains some subset of the bodies in the mechanism.

Set 1: Constrain the chassis only.

SetConstraints[cs[1], cs[2], cs[3], cs[4]]

Set 2: Constrain the chassis and right carrier.

SetConstraints[cs[1], cs[2], cs[3], cs[4], cs[5], cs[6], cs[7], cs[8]]

Set 3: Constrain the chassis and left and right carriers.

SetConstraints[cs[1], cs[2], cs[3], cs[4], cs[5], cs[6], cs[7], cs[8], 
      cs[9], cs[10], cs[11], cs[12]]

Set 4: Constrain the chassis and right carrier and rocker.

SetConstraints[cs[1], cs[2], cs[3], cs[4], cs[5], cs[6], cs[7], cs[8], 
      cs[13], cs[14]]

Set 5: Constrain everything but the right toggle.

SetConstraints[cs[1], cs[2], cs[3], cs[4], cs[5], cs[6], cs[7], cs[8], 
      cs[9], cs[10], cs[11], cs[12], cs[13], cs[14], cs[15], cs[16], cs[17], 
      cs[18]]

Set 6: All bodies.

SetConstraints[Array[cs, 20]]

Running the Model

CheckSystem

CheckSystem tests for certain mathematical errors. A return value of True means that no errors were found.

CheckSystem[]

SolveMech

SolveMech[t] seeks a solution that satisfies all of the constraints with the value of time T set to t. The solution is returned as a list of rules specifying the position of the origin of each body, and the Euler parameters Eo, Ei, Ej, and Ek that uniquely specify the angular orientation of each body.

SolveMech[0.0] // Chop

SolveMech[0.0, Solution -> Acceleration];

Output Functions

The length of the shock absorber is equal to the distance between the ends of the two toggles. The following function returns the left and right shock lengths as functions of the model's dependent variables. The right shock is defined as the shock that gets compressed when the right wheel bumps. In point of fact, the right shock is the rear shock.

rightshocklength := 
      Distance[Point[righttoggle, 1], Point[lefttoggle, 3]]
leftshocklength := 
      Distance[Point[lefttoggle, 1], Point[righttoggle, 3]]

Both shocks are the same length in bounce.

{leftshocklength, rightshocklength} /. SolveMech[{ .25, - .25}]

{{11.9979, 11.9979}, {12.5047, 12.5047}}

The degree of CCW body roll that would provide left and right wheel bounce of 0.25 and -0.25 inches, respectively, is calculated as follows.

a = 
       .(25/(Location[rightcarrier, 0][[2]] /. LastSolve[]))

Shock lengths differ with 1 degree of body roll to the left.

SetParameters[Bounce -> 0, Roll -> 1];
{leftshocklength, rightshocklength} /. SolveMech[a]
SetParameters[Bounce -> 1, Roll -> 0];

It can be seen that body roll induces greater deflection of the shocks than does an equivalent degree of bounce.

Velocity Solution

The following calculates the length of the shock at ride height, and the rate of change of the length of the shock at ride height, with respect to changes in T. The negative rate of change implies that the shock is getting shorter as the car bounces. The Solution -> Velocity option for SolveMech causes the first time derivatives of all of the dependent variables to be calculated.

{leftshocklength, Dt[leftshocklength, T]} /. 
      SolveMech[0.0, Solution -> Velocity]

Tabular Output

Variations in Time

Tables of solution points can be created using SolveMech. These tables can then be used to generate plots of various functions vs. time. 

SetBodies is first called with no arguments to reset all of the initial guesses to the values defined previously in their respective Body objects.  SolveMech is then used to move the initial guesses up to top-out in 2 steps.

SetGuess[];
SolveMech[{-0.5, -1.0}];

SolveMech uses a special form of iterator: the following input causes SolveMech to generate 11 solution points, with values of time varying from -1.0 to 1.5; top-out to full bounce.

postab = SolveMech[{-1.0, 1.5}, 11, Solution -> Velocity];

Plot of Wheel to Shock Leverage Ratio as a Function of Bump Height:

This plot shows that this suspension is a "rising rate" suspension.

\(\(ListPlot[{T, \(-Dt[rightshocklength, T]\)} /. postab, 
	
        PlotJoined -> True, 
	Frame -> True, 
	
        PlotRange -> All, 
	GridLines -> Automatic, 
	
        FrameLabel -> 
          {"Bounce", "Leverage.", "Wheel to Shock Leverage", 
            ""}];\)\)

Plot of Shock Length as a Function of Bump Height:

\(\(ListPlot[{T, rightshocklength} /. postab, 
	
        PlotJoined -> True, 
	Frame -> True, 
	
        PlotRange -> All, 
	GridLines -> Automatic, 
	
        FrameLabel -> 
          {"Bounce", "Shock Length", "Shock Length vs. Bounce", 
            ""}];\)\)

Plot of Camber Angle as a Function of Bump Height:

\(\(ListPlot[
        {T, 1/Degree\ IncludedAngle[Line[rightcarrier, 0, {0, 0, 1}], 
                  Line[ground, 0, {0, 1, 0}]] - π/2} /. postab, 
	
        PlotJoined -> True, 
	Frame -> True, 
	
        PlotRange -> All, 
	GridLines -> Automatic, 
	
        FrameLabel -> 
          {"Bounce", "Camber", "Camber Angle", ""}];\)\)

Plot of Tire Scrub as a Function of Bump Height:

\(\(ListPlot[
        {T, \(Location[rightcarrier, 
                  4]\)[[2]] - 
              \((\(Location[rightcarrier, 
                      4]\)[[2]] /. 
                  postab[[11]])\)} /. 
          postab, 
	PlotJoined -> True, 
	Frame -> True, 
	
        PlotRange -> All, 
	GridLines -> Automatic, 
	
        FrameLabel -> 
          {"Bounce", "Tire Scrub", "One Tire Scrub", ""}];
      \)\)

Variations in  Rocker Length

To create a table of solution points while varying some parameter other than time, the Mathematica Table function is used.

SetGuess[];
postab = 
        Table[SetParameters[RockerLength -> i]; 
          SolveMech[0.0, Solution -> Velocity], {i, 2.0, 4.0, 0.2}];

SetParameters[RockerLength -> 3];

Plot of Wheel to Shock Leverage as a Function of  Rocker Length, with Bump Held Constant at Zero:

\(\(ListPlot[{RockerLength, \(-Dt[rightshocklength, T]\)} /. postab, 
	
        PlotJoined -> True, 
	Frame -> True, 
	
        PlotRange -> All, 
	GridLines -> Automatic, 
	
        FrameLabel -> 
          {"Arm Adjustment", "Leverage", 
            "Wheel to Shock Leverage vs. Rocker Length", ""}];\)\)

Graphic Images

Mech3D Graphic Objects

Here is a graphic object of chassis and ground plane.

\(\(chassisGr = 
        Graphics3D[
          {
			Thickness[ .007], 
			Line[
              {{\(-7\), \(-27\), 0}, {7, \(-27\), 0}, {7, 27, 0}, 
                {\(-7\), 27, 0}, {\(-7\), \(-27\), 0}}], 
			Edge[
              chassis, {2, 3, 9, 8, 2}, {5, 6, 12, 11, 5}, {2, 3, 6, 5, 2}, 
              {8, 9, 12, 11, 8}, {8, 13, 9}, {11, 14, 12}, 
              {2, {\(-14\), 9, 11}, {\(-14\), \(-9\), 11}, 5}, 
              {8, {\(-12\), 8, 4}, {\(-12\), \(-8\), 4}, 11}, 
              {{\(-14\), 9, 11}, {\(-12\), 8, 4}, {\(-14\), \(-9\), 11}, 
                {\(-12\), \(-8\), 4}, {\(-14\), 9, 11}}]}];\)\)

Here is a graphic objects of wheel carriers.

rightcarrierGr = 
        Graphics3D[
          {Thickness[ .003], Bar[Line[chassis, 2, rightcarrier, 1],  .5, 4], 
            Bar[Line[chassis, 3, rightcarrier, 1],  .5, 4], 
            Bar[Line[chassis, 8, rightcarrier, 0],  .5, 4], 
            Bar[Line[chassis, 9, rightcarrier, 0],  .5, 4], 
            Bar[Line[rightcarrier, 0, 1],  .8, 6], 
            Wheel[Line[rightcarrier, 3, 2], 10. , 14], 
            Edge[rightcarrier, {3, 2}]}];
leftcarrierGr = 
        Graphics3D[
          {Thickness[ .003], Bar[Line[chassis, 5, leftcarrier, 1],  .5, 4], 
            Bar[Line[chassis, 6, leftcarrier, 1],  .5, 4], 
            Bar[Line[chassis, 11, leftcarrier, 0],  .5, 4], 
            Bar[Line[chassis, 12, leftcarrier, 0],  .5, 4], 
            Bar[Line[leftcarrier, 0, 1],  .8, 6], 
            Wheel[Line[leftcarrier, 3, 2], 10. , 14], 
            Edge[leftcarrier, {3, 2}]}];

Here is a graphic objects of right and left rockers.

rightrockerGr = 
        Graphics3D[
          {Thickness[ .003], 
            Bar[Line[rightrocker, 1, rightcarrier, 1],  .25, 4], 
            Facet[rightrocker, {0, 1, 2}], 
            Extrude[{Point[rightrocker, 0], Point[rightrocker, 1], 
                Point[rightrocker, 2], Point[rightrocker, 0]}, 
              Vector[rightrocker, {-1, 0, 0}], 0.5]}];
leftrockerGr = 
        Graphics3D[
          {Thickness[ .003], 
            Bar[Line[leftrocker, 1, leftcarrier, 1],  .25, 4], 
            Facet[leftrocker, {0, 1, 2}], 
            Extrude[{Point[leftrocker, 0], Point[leftrocker, 1], 
                Point[leftrocker, 2], Point[leftrocker, 0]}, 
              Vector[leftrocker, {-1, 0, 0}], 0.5]}];

Here is a graphic object of left and right toggles.

lefttoggleGr = 
        Graphics3D[
          {Bar[Line[rightrocker, 2, lefttoggle, 2],  .25, 4], 
            Bar[Line[righttoggle, 1, lefttoggle, 3], 1. , 6], 
            Bar[Line[lefttoggle, 1, 3],  .6, 4], Thickness[ .005], 
            Edge[lefttoggle, {0, {0, 0, 2}}]}];
righttoggleGr = 
        Graphics3D[
          {Bar[Line[leftrocker, 2, righttoggle, 2],  .25, 4], 
            Bar[Line[lefttoggle, 1, righttoggle, 3], 1. , 6], 
            Bar[Line[righttoggle, 1, 3],  .6, 4], Thickness[ .005], 
            Edge[righttoggle, {0, {0, 0, 2}}]}];

Graphics Displays

SolveMech[1.2] // Chop

Gr = 
        Show[{chassisGr, rightcarrierGr, leftcarrierGr, rightrockerGr, 
              leftrockerGr, lefttoggleGr, righttoggleGr} /. LastSolve[], 
          PlotRange -> {{-15, 11}, {-28, 28}, {-1, 21}}, 
          ViewPoint -> {1.55, - .9, 1.0}];

Gr2 = 
        Show[({chassisGr, rightcarrierGr, leftcarrierGr, rightrockerGr, 
                    leftrockerGr, lefttoggleGr, righttoggleGr} /. #1 &) /@ 
            %355, PlotRange -> 
            {{-15, 11}, {-28, 28}, {-1, 21}}, 
          ViewPoint -> {1.55, - .9, 1.0}];

graph  =  
      {chassisGr, rightcarrierGr, leftcarrierGr, rightrockerGr, leftrockerGr, 
        lefttoggleGr, righttoggleGr}

postab = %355

(Show[graph /. #1] &) /@ postab;

SolveMech[{0.0, 1.2}, 10] // Chop

Static Loads

Loads are applied to the model to simulate the shock absorbers. Load 1 simulates the right shock spring, with a specified spring free length and spring rate. Load 2 models the left shock spring.

ld[1] = 
        Force[lefttoggle, righttoggle, Line[righttoggle, 1, lefttoggle, 3], 
          SpringRate (FreeLength - rightshocklength)];

ld[2] = 
        Force[righttoggle, lefttoggle, Line[lefttoggle, 1, righttoggle, 3], 
          SpringRate (FreeLength - leftshocklength)];

SetParameters[SpringRate -> 50, FreeLength -> 14.20];

SetLoads applies the load objects to the model.

SetLoads[ld[1], ld[2]]

The following two inputs return the reaction forces that the ground applies to the bottom of each tire at ride height; the ground is pushing up on each tire with 99 pounds of force. 

Reaction[8, rightcarrier] returns the reaction forces that constraint number 8 applies to the right wheel carrier.

SetGuess[];

Reaction[8, rightcarrier] /. 
      SolveMech[0.0, Solution -> Static]

Reaction[12, leftcarrier] /. LastSolve[]

Since there are not, as yet, any gravitational loads applied to the chassis, the vertical driving constraint (constraint 3) must apply a 197 pound downward load to the chassis, to counter the 98 pound upward force on each tire.

Reaction[3, chassis] /. LastSolve[]

A load representing gravity is added so that the equilibrium position of the chassis can be found. The mass of the chassis was already defined in the chassis Body object. Total weight on front of car is 193.2 pounds.

ld[3] = Gravity[{0, 0, -1}, 386.4];

SetLoads[ld[3], AddLoads -> True]

The gravitational loads now almost balance the suspension loads. Constraint 3 is the constraint that controls the vertical motion of the chassis.

Reaction[3, chassis] /. SolveMech[0.0, Solution -> Static]

Constraint 4 is the constraint that controls the roll of the chassis. There is no load on this constraint because the chassis loading is symmetrical.

Reaction[4, chassis] /. LastSolve[]

Two loads representing the side loads induced by a right hand corner are added to the bottom of each tire. The magnitude of the side load on each tire is proportional to the normal force on the tire, representing kinetic friction. This condition would probably only exist during a slide, but the normal case is indeterminate, so this has to do.

ld[4] = 
        Force[rightcarrier, 
          Axis[Point[rightcarrier, 4], Vector[ground, {0, 1, 0}]], 
          CoefFriction Reaction[8, rightcarrier][[1, 
              3]]];

ld[5] = 
        Force[leftcarrier, 
          Axis[Point[leftcarrier, 4], Vector[ground, {0, 1, 0}]], 
          CoefFriction Reaction[12, leftcarrier][[1, 
              3]]];

SetParameters[CoefFriction -> 0];

SetLoads[ld[4], ld[5], AddLoads -> True]

Equilibrium

A FreeSystem is built that has had constraints 3 and 4 dropped, the constraints that control the vertical position and the rotation of the chassis. This allows the chassis to move to its equilibrium position.

freesys = SetFree[{3, 4}];

sol = SolveFree[freesys]

The car is in equilibrium at a ride height of 1.5339 inches.

rideheight := 
      Location[chassis, 0][[3]]

rideheight /. sol

There is no chassis roll in this load state.

bodyrollangle := 
      1/Degree (IncludedAngle[Vector[chassis, {0, 0, 1}], 
              Vector[ground, {0, 1, 0}]]) - 90

bodyrollangle /. sol

The car is now put into a 1 G right-hand turn.

SetParameters[CoefFriction -> 1];

sol = SolveFree[freesys];

The ride height of the car has gone up a bit,

rideheight /. sol

which results in 0.22 degrees of body roll to the left.

bodyrollangle /. sol

Component Loads

Note: All of the following loads are based on the results of the 1 G right-hand corner equilibrium calculation.

The load vectors, in global coordinates, applied to the right and left wheel carrier upper A-arm attachment points by the upper A-arms:

Reaction[5, 
          Point[rightcarrier, 1]][[1]] 
      /. sol
Reaction[9, 
          Point[leftcarrier, 1]][[1]] /. 
      sol

The load vectors applied to the right and left wheel carrier upper A-arm attachment points by the upper tie rods:

Reaction[14, 
          Point[rightcarrier, 1]][[1]] 
      /. sol
Reaction[16, 
          Point[leftcarrier, 1]][[1]] /. 
      sol

The magnitudes of the tensile forces in the right and left upper tie rods.

Magnitude[%%]
Magnitude[%%]

The load vectors, in global coordinates, applied to the right and left wheel carrier lower A-arm attachment points by the lower A-arms:

Reaction[6, 
          Point[rightcarrier, 0]][[1]] 
      /. sol
Reaction[10, 
          Point[leftcarrier, 0]][[1]] /. 
      sol

The magnitudes of the tensile forces in the right and left lower tie rods.

Magnitude[
        Reaction[17, 
            Point[rightrocker, 
              2]][[1]]] /. sol
Magnitude[
        Reaction[19, 
            Point[leftrocker, 
              2]][[1]]] /. sol

The load vectors, in global coordinates, applied to the right and left toggles by the chassis, at their pivot axes on the chassis.

Reaction[20, 
          Point[righttoggle, 0]][[1]] /. 
      sol
Reaction[18, 
          Point[lefttoggle, 0]][[1]] /. 
      sol

The loads in the right and left shocks.

SpringRate * (FreeLength - rightshocklength)/.sol
SpringRate * (FreeLength -  leftshocklength)/.sol

Other Forces

ld[1] = 
        Force[lefttoggle, 
          Line[ground, Location[lefttoggle, 1] {-1, -1, 1}, 
            lefttoggle, 3], 
          SpringRate (FreeLength - 
                Magnitude[
                  Location[lefttoggle, 3] - 
                    Location[lefttoggle, 1] {-1, -1, 1}])];

ld[2] = 
        Force[lefttoggle, 
          Line[ground, Location[lefttoggle, 3] {-1, -1, 1}, 
            lefttoggle, 1], 
          SpringRate (FreeLength - 
                Magnitude[
                  Location[lefttoggle, 1] - 
                    Location[lefttoggle, 3] {-1, -1, 1}])];