1. Introduction to using SOLIDWORKS to synthesize mechanisms
2. Adapting traditional graphical methods
3. 4-bar linkage motion generation
4. Optimizing mechanisms for size and smooth motion

This article builds on these previous ones, providing a real-world example of optimizing a mechanism with many different constraints. Where the constraints are too complex to represent in a single sketch, a multi-step approach can be used.

A sketch is set up to solve the mechanism for one configuration of parameter values. A script is then used to solve this sketch for many different configurations and record the values of driven dimensions. Finally, a spreadsheet is used to analyze the results and find the optimum design. In practice some iteration through these steps is required, as shown in the process flowchart below.

A script was created using the SOLIDWORKS API to read in the configurations, solve the model and store the results. It uses three simple text files for inputs and outputs:

Inputs.txt:

This file is created by the user to define the problem to be solved. It has three lines:

• The file name of the SOLIDWORKS part to open and interact with.
• A comma separated list of the driving parameters to be updated by the script.
• A comma separated list of the driven parameters to be recorded by the script.

Parameters.txt:

This file is also created by the user. Each line represents a different configuration as a comma separated list of values with each value corresponding to one of the driving parameters listed on the second line in inputs.txt.

Outputs.txt:

This file is created by the script. It has a similar structure to parameters.txt, with each line also representing a different configuration as a comma separated list of values for each parameter. In this case it is the driven parameters listed on the third line of inputs.txt that are listed.

Understanding the Constraints

The BriefBike design brief was that it needed to unfold, in under half a second, into a stable two-wheeled roller case format. It also needed to have riding geometry comparable to a normal bike and be structurally efficient.

Previously, an early prototype demonstrated the bike can be unfolded in less than half a second. But this design was too wide when folded and the complex relationship between constraints was making further improvement challenging.

BriefBike was designed to have a wide two-wheeled base that can be easily dragged behind you on two smaller castor wheels. This is in contrast to current folding bikes which, when fitted with castor wheels, behave more like the much less stable four-wheeled roller cases. These narrower designs must be pushed in front of you and actively steered rather than simply following along behind. Because the propulsive force comes from a hand quite some distance above the small wheels, they are very prone to tipping over. To be able to move quickly and navigate uneven surfaces, you need two wheels located quite far apart and to be able to pull it along behind you. This then creates a natural trailing link suspension effect.

A key design requirement for BriefBike was that it needed a wide two-wheeled base that could be easily dragged behind the rider.

Before creating the actual mechanism synthesis sketch, a simpler sketch was created to define the basic ride geometry of the bike. This includes parameters such as the wheelbase, trail and head angle. A linear dimension was used to drive the head angle as this was easier to work with in the API.

The RideGeom sketch defined the important parameters affecting the handling of the bike. This was then used as a reference for the LinkSynth sketch which solves for the linkages which enable the bike to fold.

The actual mechanism synthesis is performed by a sketch which shows the four-bar linkage in two positions – folded and riding. Each link is constrained to be the same length in both positions. By adding dimensions and constraints until the sketch is fully constrained, the link lengths and joint positions are determined. Setting up this sketch to robustly solve with a wide range of different parameter values was the most challenging aspect. It was also necessary to change the constraints somewhat as the design evolved.

The main four-bar linkage is represented in this sketch, with the ground link not actually drawn. The three non-grounded links are drawn in the riding position with a thick dotted line and in the folded position in a thick solid line.

Even with this automated approach, it is not possible to solve for every conceivable combination of parameters. The model has a total of 16 driving parameters. If each parameter had just five values, the total combinations would be 150 billion and take hundreds of years for SOLIDWORKS to solve. The method therefore starts with manually testing each parameter, getting a feel for the impact that adjustments make. Only when interactions become difficult to properly explore in this way is the script used to explore an area of the parameter space.

This project went through six iterations, with up to 40,000 configurations tested at a time. Generating a table with all the different combinations is what’s known in design of experiments as a full factorial set. For large parameter sets, an automated approach is needed to create this table. This can be done using Power Query, which comes with Excel.

First, a table is created in Excel for each parameter, listing the values to be tested. Each table is then connected to a query in Power Query which generates a single, much larger table with all the possible combinations. The actual process is a little involved but is explained clearly in this YouTube video. The table of configurations can then be exported into a text file that the script can read.

After the script had solved all the different configurations, I placed all the input driving dimensions and all the output driven dimensions into a single Excel table. This had a column for each parameter and a row for each configuration. I then created additional columns to calculate things like joint forces based on the lengths of frame members. Once all this data was in a single table, configurations could be filtered to find those with the best performance.

This resulted in finding a design with a longer wheelbase, steeper head angle, more direct transmission angles, lower joint forces and a more compact folded package. You can find out more about BriefBike at www.BetterBicycles.org

SOLIDWORKS simulation provides a wide range of tools to simulate stress in mechanical parts. As with any simulation, the results are only as good as the assumptions we make when setting up the model and analyzing the results. This article focuses on the way we interpret the calculated stress to determine whether a part will fail.

Before we get into determining whether your part will fail, it’s important remember that this is only one aspect of a good stress analysis. It’s also vital that the boundary conditions and mesh realistically simulate the loading of your part.

The first question to ask is whether the boundary conditions accurately represent the way the part will be loaded. The mesh must be of sufficient quality to provide numerically accurate calculations. Aspect ratio is one important measure of mesh quality, this means that the triangular faces of elements should be as close to equilateral triangles as possible. Very elongated elements with high aspect ratios over 3 will reduce the accuracy of the simulation. Similarly, distorted elements, as measured by the Jacobian, may cause the simulation to fail.

Selecting Mesh Details from the context menu of the element in the simulation tree brings up useful information to evaluate mesh quality. Geometry should be simplified, and mesh controls should be added to achieve a reasonable mesh quality.

Another important consideration for the mesh is whether it has sufficient detail to provide the actual maximum stress with stress concentrations.

There can be something of a trade-off here between removing features to improve mesh quality and maintaining the features that will actually affect the result. This is somewhere that the skill and experience of a stress analyst can be very valuable.

Simulation using finite elements usually isn’t actually the best way to determine the peak stress within stress concentrations. It’s much better to use the FEA to determine the stress field surrounding the stress concentration, and then determine the actual peak stress using an analytical method. Formulas for a wide range of features and loading conditions can be found in reference books such as Roark's Formulas for Stress and Strain, or Peterson's Stress Concentration Factors.

This is a very brief overview of what’s required to perform a good stress analysis. So, assuming you have accurately determined the stress in the part, how do you know whether it will fail?

Failure Criteria

Material failure may occur under static stress, fatigue or buckling. Under static stress conditions, materials generally fail in one of two ways, either by brittle failure (fracture) or by ductile failure (yield).

Mild steel is a typical example of a ductile material and ceramic is an example of a brittle material, although almost any material can behave in a brittle way under conditions such as very low temperature or highly cyclic loading. Similarly, most materials can be ductile at very high temperature. Over the full range of typical conditions, most materials can be considered to be either brittle or ductile. However, some materials, such as aluminium alloys, are a little less clear – a single large force is likely to result in yielding while a cyclic fatigue load will result in fracture.

The way that failure is defined may also vary according to the way a part is used. For example, if a shackle on a safety harness yields while arresting a fall, this probably doesn’t constitute a failure. In fact, it may be desirable for the shackle to yield, since this will dissipate some energy, protecting both inline equipment and the falling person from higher peak forces. [Hopefully, the shackle carries a warning that it should not be used after a fall, now that it has a shape different than its design shape. --Ed.]

In this case, a simple failure criterion could be when the average stress over its cross section exceeds the material’s ultimate tensile stress. However, if the same shackle was used as lifting gear, requiring repeated use, then yielding would be considered as a failure of the part. In this case, the same part, undergoing the same loading, can have different failure criteria – defined according to the usage requirements.

Some potential physical mechanisms for failure include yielding, fracture and buckling. A different analysis is required to check for each failure criteria.

For a part loaded in pure tension, the yield criterion is simply the yield stress for the material. However, most parts have more complex loadings, resulting in a three-dimensional combination of tension, compression and shear.

The simplest way to deal with this is to resolve the stresses into their principal directions, using Mohr’s circle. If these individual values are less than the material’s yield stress, this theory would assert that it shouldn’t fail. The principal stress approach is a simplification and other failure theories take a more sophisticated approach to determine when yield will occur. They consider the micro-mechanics of materials, involving atoms slipping within the crystal lattice and grain boundaries moving over each other.

Different approaches should, therefore, be used for ductile and brittle materials. They typically assume that a material is ductile and isotropic, meaning it has the same strength and stiffness in all directions. Metals can generally be considered to be isotropic, while wood and composites cannot.

The most common failure criteria used for static stress are von Mises, Tresca and maximum normal stress. They all involve first calculating principal stresses and then combining them into a single stress value that represents the stress at a point in the 3D solid. If this combined stress is less than the tensile yield stress for the material, it should not yield.

Von Mises and Tresca are used for ductile materials, while maximum normal stress is used for brittle materials. Von Mises is the most common, used for most static stress analysis. Tresca is very similar, but can give slightly higher stress values under certain circumstances; it is therefore more conservative, resulting in improved safety.

There is no stress plot listed as Tresca in SOLIDWORKS simulation but the Stress Intensity (P1-P3) gives the same values as Tresca.

For brittle materials, it is best to use the maximum principal stress (P1). However, brittle materials may require more detailed consideration of their fracture mechanics, which describes the way that cracks propagate and result in sudden and catastrophic failures.

Many theoretical failure criteria have been devised for brittle failure. The below plots show that for von Mises, Tresca and maximum principal stress, the results are very similar but slightly different maximum values are calculated.

In this article, I’ve given a quick overview of some of the most important failure criteria for failure under static stress.

It’s important to also check whether your part might fail under buckling or fatigue. In an ideal world, we would have clear rules for which failure criteria to apply for specific materials, loading conditions and functional requirements. Unfortunately, material science isn’t quite there yet. Instead, a number of different theories are in use and each has strengths and weaknesses.

Although a skilled analyst can consider relevant criteria for each case, ultimately no simulation can be considered an infallible way to determine whether a part will fail. Ultimately, testing is still required. Simulation, can however, dramatically reduce the number of design and test iterations.

Simulation is more useful for providing rich qualitative data showing stress fields than it is in predicting exact failure. This can be invaluable in assisting a designer, or optimization algorithm, to design parts which put material where it is needed to carry loads.

To learn more about analysis with SOLIDWORKS Simulation, check out the eBook Understanding Nonlinear Analysis.

The two examples in this article each take a step-by-step approach to synthesising a mechanism, using SolidWorks. The first example is in some ways extremely simple, involving a single linkage rotating about a revolute joint. It is complicated because the starting and finishing positions of the link are known but the required plane of motion is not known. It is therefore a 3D problem which is difficult to solve with conventional graphical methods but which can be easily solved using the correct method in a 3D sketch. The second example is a four-bar linkage which is synthesised to produce a specified motion path.

There is something of a gap in the pre-packaged tools and published methods for mechanism design. There are a lot of tools available within CAD software to analyze mechanisms once the basic linkage design has been created. These provide information about the paths, forces, accelerations and other dynamics of a mechanism which has already been defined. Methods of synthesising a mechanism to produce some required motion are also well known within classical machine design and specialized software exists which recreate these methods. However, it is often far more convenient to use your existing software to perform this task. This is a great example of the enormous power of the geometric constraint solver which lies at the heart of the constraint based sketching in a parametric CAD program such as SolidWorks. With creative use, constraint based sketching can be used to intuitively solve many problems, from machine design to optics.

Synthesizing a single linkage for a 3D transformation

My first example involves moving an object from one pose (position and orientation) to another pose, by rotating it about a single axis. The problem involves finding the axis of rotation which will produce this transformation. This could be solved mathematically by solving the transformation matrix but it is often more convenient to do this within the CAD software. I’m using a simplified aircraft landing gear, perhaps on a model aircraft, which must move between a position on the ground, aligned with the forward direction, to a position flush with the tail of the aircraft.

Defining wheel poses – the design intent for the mechanism synthesis

We start by defining our design intent with a series of sketches in a master assembly file. These give the deployed and stowed poses for the wheel. I have provided a step-by-step account of how I have done this although there are many ways it could be achieved. If you don’t want to recreate this geometry, you can skip to the actual mechanism synthesis section.

First, sketch a plan view showing the rear fuselage section and wheel position:

Figure 1: Plan view defining the rear fuselage profile and wheel position.

And next, a side view of the wheel in its deployed position, sketched on the center plane for the wheel:

Figure 2: Creating the center plane for the wheel.

Figure 3: Side view of deployed wheel position.

Next, we create a fuselage part and define the profile and centreline in the context of the assembly, using the sketch we just created to reference the part geometry. We then revolve a thin solid in this part to represent the outer skin of the fuselage:

Figure 4: Fuselage part defined in context of assembly.

After revolving the fuselage I realised the wheel was not positioned low enough, so I also corrected this position:

Figure 5: Revolved fuselage and corrected wheel position.

In order to conceal the wheel within the fuselage,while consuming minimum space,define the stowed position of the wheel,tangential to the fuselage and offset by half of its thickness. I located this by first sketching a construction line in the original plan view sketch, giving its plane-normal vector and position:

Figure 6: Adding a line to define the wheel’s stowed pose.

The plane of the stowed wheel position is then defined at the end of and perpendicular to this line:

Figure 7: Creating the center plane for the wheel in its stowed pose.

To help with visualisation, you can add a sketch showing the final pose of the wheel. This completes the definition of the wheel poses – the design intent for the mechanism synthesis.

Figure 8: Final definition of the wheel poses – the design intent for the mechanism synthesis.

Mechanism synthesis

Going back to the original problem definition, we are trying to define a single axis of rotation which will rotate the wheel from the deployed pose to the stowed pose. To synthesize such a mechanism, we can define the required axis in terms of geometric constraints by first applying some Euclidean thinking. The axioms, or in this case kinematic truths, are that to obtain the required motion:

1. To rotate about an axis from one pose to another, all points on the wheel must move in circular paths about a common axis by the same angle.
2. A circular path maintains a common distance from a point in space.
3. All points on a circle lie on a common plane which is perpendicular to the axis of rotation.
4. We require the wheel’s pose to be defined in 5 degrees-of-freedom, we don’t care about rotation of the wheel about its axis. Therefore,if we satisfy the 2^nd and 3^rd axioms for two points on its axis,we will obtain the required rotation to the final pose in the required 5 degrees of freedom.

Translating these axioms into sketch constraints,we create the following geometry and constraints in a single 3D sketch:

1. We choose an arbitrary first point on the wheel’s axis. For convenience, I will use the center. We sketch a line between the wheel center in the first pose and an arbitrary point in space. To do this we need to be in a 3D sketch and it is important that the line is not constrained in any other way. We then sketch a second line, between the center of the wheel in the second pose and the arbitrary end of the first line. We apply a constraint to make these two lines equal in length, satisfying the 2^nd
2. We do the same thing for a second point on the wheel’s axis, in keeping with the 4^th
3. We now create a 5^th line, joining the intersection points for the two pairs of lines created in steps 1 and 2. This line will become the axis of rotation we are trying to find.
4. We make each of the four lines created in steps 1 and 2 perpendicular to the axis we created in step 3. This satisfies the 3^rd axiom for the two points. At this point, we should find that the 3D sketch is fully constrained and that the axis we created in step 3 is now the desired rotation axis. We can test this by assembling a new component to rotate about it.

Now let’s put this into practice. Begin by creating a new 3D sketch. All of the following geometry, used to locate the axis of rotation, should be created in the same 3D sketch, allowing the constraint solver to solve for the entire problem definition. First, we need two common points on the wheel axis. For convenience, we will use the center of the wheel as the first point and the second point will be the other end of the normal-vector line we created for the wheel in its stowed position. So we only need to create a single line on the deployed wheel, of equal length to the line on the stowed wheel.

Figure 9: Line defining the second point on the wheel in its deployed position.

Next, create two lines, one starting at the center point of each wheel and joined at an arbitrary point in space. To ensure that this point is truly arbitrary, be sure that the lines are not constrained in any way. Check them by selecting them in turn, and if any automatic sketch relations have been created then delete these relations. Also, try dragging the lines around to ensure that they are constrained to the wheel centers and that they are joined to each other. Finally, select both lines and make them of equal length.

Figure 10: Lines of equal length connecting common points in the two poses to their common axis of rotation.

Now, repeat this process to create two more lines connected to the 2^nd points on the wheel poses and meeting at their other ends. Again, check that the lines are properly connected and that there are no unwanted automatically-created sketch relations, before making the lines of equal length.

Figure 11: Lines of equal length connecting the second pair of common points in the two poses.

Now we create the axis which has been the aim of our mechanism synthesis:

Figure 12: Creating the axis of rotation.

Finally, create sketch relations making each of the four lines connected to the axis, perpendicular with the axis. As you are creating these constraints, you may find that the sketch fails to solve, with lines becoming red and yellow. If this happens, undo the last sketch relation and drag the lines to a new location before recreating the constraint. There is a bit of intuition involved in moving them to a sensible location, reasonably close to where the rotation axis should be. Try to visualize how the wheel should be rotating and be patient if you need to repeat this step a few times before the sketch solves.

Figure 13: Creating the final perpendicular constraint to fully define the sketch and solve for the axis of rotation.

Once you have made all four lines perpendicular to the axis, all geometry should turn black, indicating that the sketch is now fully defined. You might not be entirely convinced yet, but this should mean that the axis is now in the required position and orientation to rotate the wheel exactly from its deployed pose into its stowed position and orientation. You should now exit the 3D sketch and save the model. Any subsequent geometry creation can now reference this sketch.

Verifying the mechanism synthesis

To verify that the axis of rotation does indeed move the wheel between the required poses, we can create a component and drag it between them. A wheel component can be created in the context of this assembly which is fixed in the deployed pose and has a reference line on the line which defines the axis of rotation that we just created. If a second instance of this component is then inserted into the assembly, it can be mated to the rotation axis, so that the wheel can be dragged about the axis of rotation to validate the motion path.

Figure 14: Validating the motion by dragging a wheel component mated to the axis.

Note that although in the construction sketch, which we have just created, the axis of rotation was drawn as a short line, the actual axis of rotation is of infinite length. You may wish to consider where along this axis you would actually want to position a pivot bearing. You may notice that it is not really possible to find a convenient location for the pivot bearing, which would ideally be close to the lower surface of the fuselage and between the poses. In a future article, I will look at how to synthesize some more complex mechanisms which might be more practical for this application.

Synthesizing a planar 4-bar linkage

Another common type of mechanism is a planar 4-bar linkage. These can be synthesised to produce more complex, non-circular motion paths, or to create more compact mechanisms. The method used to synthesize a planar 4-bar linkage is quite different to the previous example. Since the mechanism is planar, all the construction geometry used to synthesize it can be created as normal 2D sketches on a single plane. Also, since the axes of revolute joints are perpendicular to this plane of motion, these joints may be simulated by simply using unconstrained connections at the endpoints of lines. If the mechanism contains a prismatic, or sliding, joint then this can be simulated by making the endpoint of a one-line coincident with another line. These methods of quickly mocking-up mechanisms are well known and sketch blocks may also be defined in this way within SolidWorks. However, the methods explained here go beyond simply modelling the motion of a mechanism to actually synthesizing the mechanism to produce a specified motion path.

It should be noted that different arrangements of 4-bar linkages produce quite different types of motion. Essentially the same method is used to synthesize each of them, but this is likely to fail if you start with the completely wrong initial arrangement. I give one example here, but if you require a completely different type of motion then you should first familiarize yourself with the many standard configurations of 4-bar linkage. There are many books and websites which cover these.

The fundamental method for the synthesis of all types of 4-bar linkage is to:

1. Define a number of positions along the desired motion path.
2. In a single sketch:
   1. Approximately sketch the mechanism located at each of these positions, ensuring that the stationary, or ground, link is constrained to have a common position for each of these.
   2. Add constraints so that the linkages in each position are the same size and shape, differing only in position.
   3. Add any dimensions or constraints necessary to fully constrain the sketch, using these to obtain a mechanism which meets any as yet undefined objectives.
3. Sketch the mechanism in one more intermediate position, again located to the ground by the same joints and having the same linkage lengths.
4. Drag this final sketch through the range of required motion, validating that the correct motion is obtained and that it doesn’t have issues such as jamming or reversing.
5. If necessary, make any modifications to the additional dimensions and constraints, created in step 4, in order to correct any issues encountered. This may not be possible in some cases and you might need to try a different configuration of 4-bar linkage or some other more complex mechanism.

One of the many 4-bar linkages to approximate straight line motion

In this example, we will synthesize a mechanism to produce a motion path 100mm long with a radius of approximately 10m. Although this could be achieved with a simple revolute joint, located at a radius of 10m, this would be a very large mechanism for a movement of just 100mm. Using a 4-bar linkage, we can create a far more compact mechanism. First, we create a simple sketch with the desired motion path.

Figure 15: Sketch defining desired motion path.

Next,create another sketch containing the 4-bar linkage mechanism in three approximate positions, each constrained to a point on the motion path. The point on the ‘floating link’ which actually follows the motion path is known as the ‘coupler point.’ For simplicity, the midpoint of the floating link has been used as the coupler point in this example. For more complex motions, the coupler point may be easily offset from the axis of the floating link by creating a triangle instead of a single line to represent the floating link. If you do this, just be sure to make each side of the triangle the same length in each position.

For clarity, each position has been coloured differently in the image below and the joints fixed to the ground have been annotated with the standard symbol for a fixed support.

Figure 16: Approximate mechanism sketched in three positions.

Each of the three moving linkages is then constrained so that it is of equal length in each position.

Figure 17: Links constrained to be equal lengths in each position.

Finally, additional dimensions are added as required. I’ve chosen to set the lengths of the linkages (aiming for a compact mechanism) and the minimum transmission angle (to ensure that the mechanism does not lock). The minimum acceptable transmission angle depends on a number of factors such as the power to be transferred, the required efficiency and the bearings used.

Figure 18: Final constraints added to fully define the mechanism.

The final step is to validate the mechanism. In a separate sketch, the mechanism is sketched again using the same ground joint positions and link lengths but without constraining it to any point on the motion path. This can then be dragged through the range of motion to validate that it functions as intended.

Figure 19: Final sketch of the mechanism which can be dragged to validate the motion.

Conclusion

I hope you found this introduction to mechanism synthesis using SolidWorks helpful. By thinking about geometry, the techniques can be adapted to solve many mechanism synthesis problems involving both planar and 3D mechanisms with up to 4 linkages. In my next article, I will cover some more advanced techniques for synthesizing more complex mechanisms. I would like to give credit to Satyajit Ambike and James Schmiedeler for their work on Geometric Constraint Programming for mechanism design, which opened my eyes to using CAD software in some new ways.

About the Author

Dr. Jody Muelaner’s career began in machine design, working on everything from medical devices to saw mills. He trained in AutoCAD in 1997 and transferred to SolidWorks in 2002. Since 2007 he has also been involved with quality engineering in aerospace manufacturing. This work unifies SPC, MSA and metrology to enable optimized production systems. His interests also include bicycle design. Visit his website for more information: www.muelaner.com