Universal Tensile Testing Machine VERSION TWO

This project is a newer, redesigned version of the ORIGINAL Tensile Testing Machine.

This instructable contains BOTH design steps and assembly instructions. Please view the table of contents for more information.

I have made a promise to publish the new version in fall in the original version. Well, here it is, the now "Universal" Tensile Testing Machine Version 2! I might publish it on Thingiverse as well (though I'm not certain).

Background Info

I am a 9th grade student at Arizona College Prep Erie Campus (at the time of designing). The project to make a tensile testing machine started all the way back in 8th grade when my friend and I wanted to make science fair projects on the tensile strengths of 3D printed testing specimens. We successfully designed a fully functional tensile testing machine in Tinkercad and used it for our Science Fair projects.

Earlier this year, I published the original version as my first instructable. It had detailed design and build instructions and was featured on the home page. I promised that a newer version will be published on Thingiverse within 2 months, but there were some major delays due to shipping. I apologize for the extended delays. Nevertheless, now the new version is published.

Purpose

The project presented in this instructable is an improved remake of the original tensile testing machine through Fusion 360. Combined with past experience and lessons, this version is much more powerful than the older one (see list below).

I will be carrying on the tradition of explaining every step of the design; this includes every bit of detail from the design process all the way to the assembly of the machine (excluding few hard-to-explain parts). This makes it so that the user understands every step made to achieve the end result.

What is a universal tensile testing machine and how does it work?

Tensile testing machines are variants of universal testing machines made specifically to test tensile strength of testing specimens. It applies a tensile force to a specimen (stretches it) until it breaks, and measures the forces applied while doing so. Although this specific machine is built with mainly tensile testing in mind, this version is now able to perform compression tests as well.

This tensile testing machine has mainly five parts: the stationary fixture, moving fixture, load cell (and its mount), and the motor (a geared NEMA 17 stepper motor). The moving fixture is attached to a load cell and controlled by the motor via a lead screw. After the specimen is loaded and a tensile test had begun, the motor rotates the lead screw. The lead screw translates rotations into linear motion, causing the the load cell to be pulled back, but the specimen resists the pulling force by exerting an equal and opposite reaction, which is then measured by the load cell. This process continues until the specimen fractures. The same process is used for compression tests, except the specimens will be loaded in the opposite direction.

Do I need advanced electronics knowledge to build this?

Depends, but usually no. You will need basic intermediate knowledge to solder the components onto the PCB. Most of the components are through-hole, and those that are SMD are not strictly required. By following the build instructions, you should be able to replicate the machine without much experience in electronics, but if you plan on customizing some features, then you need to be familiar with the required skills.

Benefits From The Original

This is a list of improvements that are made from the original version.

Hardware:

• Ability to perform compression tests
• Much less fixture deflection due to reinforcements
• Much stronger grips
• Shaft collars instead of flanged nuts to save space
• Higher torque transfer
• Designed in Fusion 360
• More detailed build guide
• More clearance in mounting holes

Electronics:

• Custom PCB for a more permanent electronics solution
• Buttons and OLED display for testing without computer
• Emergency Stop/Reset All button
• Many more testing modes, including speed selection and modulus testing.
• Support for PLX-DAQ data acquisition
• Dedicated ATTiny85 for separate stepper motor controls
• Easy to configure Arduino code

From my testing, this new version is able to handle at least 1kN of load.

Table of Contents

This is a table of contents for the different sections of this instructable:

Steps 1-66: Design Process - This is where I explain design process of this tensile testing machine.

Steps 67-68: Design Assembly - This is where I give the design files and explain how to print them.

Steps 69-79: Component Selection - This is where I explain the component selection process of this machine.

Steps 80-89: Physical Assembly - This is where I cover the physical assembly steps

Steps 90-96: Electronics Assembly - This is where I cover the assembly steps for the electronics.

Step 97: Video - a video.

Step 98: Conclusion - Brief thank you to Maker Hub Club and supporters.

I would estimate the cost to build this machine from scratch be around $180-200. If you're planning on upgrading from the ORIGINAL version, then it will cost around $75-$90 to upgrade.

Mechanical:

• 1x 550mm 2060 Eurpoean Standard Aluminum Extrusion
• 2x MGN12H Carriages
• 1x MGNR12 300mmm Rail
• 1x 400mm T12 Lead Screw, 7mm Lead, 4 Starts
• 1x T12 Flanged Nut
• 2x/1 Set 7201 Single Row Angular Contact Ball Bearings
• 1x 6001 -zz/-2rs Deep Groove Ball Bearings
• 2x 12mm Shaft Collars
• 1x D25 L40 8mm to 12mm Rigid Coupler
• 1x S-Shaped Load Cell Rated for 500kg/1T

Electrical:

• 1x Custom PCB
• 1x Arduino Nano (and cable)
• 1x ATTiny85-20PU
• 1x 12/24V Power Supply (and wires)
• 1x HX711 Board (either XFW or the red type)
• 1x StepStick Stepper Motor Driver (A4988/DRV8825)
• 1x Planetary Geared NEMA 17 Stepper Motor (51:1 to 100:1)
• 1x SSD1306 128x64 OLED Display
• 1x LM7805 (need heatsink) or Equivalent Package Buck Converter (noisy but no heatsink)
• 6x B3F-4000 Push Buttons
• A Lot of Male and Female 2.54 Pin Headers

Screws/Bolts and Nuts:

• 20x M5x14mm Button Head Screws
• 20x M3x8 Socket Head Screws
• 4x M12x50mm External Hexagon Screws
• 4x M3x22 Socket Head Screws
• 4x M3x8 Low Profile Screws
• 4x M3x8 Nuts (preferably nyloc)
• 2x M5x50mm Button Head Screws
• 2x M16x25 Screws (or what fits the load cell)
• 20x M5 T Nuts (2020 extrusion type)
• 20x M3 T Nuts (2020 extrusion type)

This marks the beginning of the design process. It is used to explain how I designed this machine. You may skip this part if you're not interested. Refer to the table of contents for which steps to start at for assembly. Click here to skip to step 67.

The tensile testing machine project originally began in Tinkercad; however, I have moved on to Fusion 360 since then. So every part of the design process will be in Fusion 360, but the fundamental principles of the machine will still be the same as version 1.

I designed the parts of the machine separately. However, if you were to follow this tutorial, you may do so in one complete assembly.

Keep in mind that this design went through several iterations before being complete; though only the final version is shown in the instructable. Also keep in mind that what I do here is NOT always the best practice, with lots of sketches unconstrained. Refer to actual Fusion 360 tutorials on how to efficiently design parts if you're a beginner.

1. To start off, create a sketch on the XY plane and make a 152x60mm rectangle.
2. Then extrude the sketch by 10mm upwards.

This is the stepper motor mount. It is used to hold the motor and its bearing block.

1. Create a sketch on the stepper motor mount.
2. Place two rectangles on the sketch, with their horizontal lines collinear with the outer edges of the base.
3. The width of the first and second rectangle are respectively 5mm and 40mm. The first rectangle is spaced from the left edge by 35mm, while the second rectangle is spaced from the right edge by 12mm.

These two parts will be used to mount the stepper motor and the bearing.

1. Create a sketch on the surface of the stepper motor bracket and follow the first picture to make the mounting hole profile.
2. Extrude the mounting holes by -5mm with the cut operation selected.

3. Create a second sketch on the motor bracket.

4. Draw 6mm circles on each of the mounting holes, like shown in the picture.

5. Extrude the circles by -2mm into the bracket with the cut operation selected.

These holes will be used to mount the stepper motor and are used to fit low profile M3 screws, but regular socket head cap works too.

1. Create a sketch on one of the sides of the bearing block.
2. Draw a 32.2mm diameter circle in the horizontal middle of the sketch, spaced 33mm from the bottom.
3. Extrude the sketch by -10mm on the cut operation.
4. Repeat the same steps on the other side.

The bearing block will have two bearing cutouts. The angular contact bearings inserted will alleviate the motor from experiencing any axial loads.

1. Create a sketch on one of the faces in the bearing cutout.
2. Draw a 20mm circle in the center of the bearing cutout.
3. Extrude the circle by -20mm in the cut operation

This is a cutout for the lead screw to fit through in the bearing block.

1. Create a sketch on any of the top three faces of the base.
2. Project the other two faces onto the sketch using the project tool.
3. Create the side walls with thicknesses like shown in the first picture.
4. Extrude the side walls in join operation by 56mm, which should merge with the top of the bearing block and stepper motor bracket.
5. Add a 35mm chamfer on the leftmost part of the side walls.

These are walls on the side that will later be used for reinforcements.

1. Create a sketch on one of the outer faces of the side walls.
2. Project the edges of the bracket and the stepper motor mount onto the sketch.
3. Draw lines/rectangles 10mm offset from the bottom like shown in the first picture.
4. Extrude the upper rectangles by -60mm in the cut operation to cut off the top parts of the side wall.

Add more chamfers to the side walls. Do them however you like.

1. Create a sketch on top of one of the faces of the base.
2. Draw multiple 5.2mm circles in the vertical middle of the stepper motor mount, spaced at least 10mm apart. Like shown in the first picture.
3. Extrude the circles by -10mm in the cut operation.
4. Create a second sketch on top of one of the faces of the base.
5. Project the other two top faces of the base onto the sketch.
6. Draw 10mm circles on where the 5.2mm circles were.
7. Extrude the sketch (excluding the circles you just drew) up by 5mm in join operation.

This will create the mounting holes for the M5 bolts to fit.

1. Add a chamfer like shown using the two distances chamfer type and add two fillets on the sides of the bearing block.
2. Extrude the base of the stepper motor mount near the right side edge by an extra 5mm.
3. Add chamfers on the edges shown in the fourth picture. This is optional.

1. Create a sketch on the face the stepper motor will be against.
2. Draw a 23.2mm diameter circle in the center of the previous cutout.
3. Extrude the hole by -2mm into the bracket using the cut operation.

This step is due to most geared stepper motors having raised bearings near the shaft.

1. Create a sketch on top of the bearing block.
2. Draw 5.2mm diameter circles with spacings like shown in the first picture.
3. Extrude the circles down in cut operation all the way.
4. Create a second sketch on top of the bearing block
5. Draw 10mm diameter circles on where the mounting holes are.
6. Extrude down by -19mm.

This step is to add reinforcement to the stepper motor mount. It is optional but strongly recommended.

The stepper motor mount is now done. Three more parts to go!

1. Create a sketch with a 60x80mm rectangle on the XY plane.
2. Extrude the sketch by 10mm upwards.

This is the moving load cell mount. It is connected with the lead screw nut and one end of the load cell.

1. Create a sketch on the top of the base.
2. Make a 20mm rectangle, spaced 5mm from the left edge.
3. Extrude the rectangle by 72mm.

1. Create a sketch on the side shown in the picture.
2. Make a the circles like shown in the second picture.
3. Extrude the sketch by -20mm on the cut operation.

This is where the T12 nut is going to be mounted.

1. Create a sketch on the face shown in the picture.
2. Draw a 16.2mm that is in the middle and spaced 15mm from the top edge. Though keep in mind that a different mounting hole size is required for load cells of different sizes.
3. Extrude -20mm on the cut operation.

This hole is used to mount the load cell. The diameter can be adjusted to fit your load cell.

1. Create a sketch on top of the base.
2. Basically draw four 3.2mm diameter circles spaced 20mm located in the middle.
3. Extrude -10mm in cut operation.

This is used to mount the part onto the MGN12H linear carriage.

1. Create a sketch on top of the base.
2. Make two 20mm wide rectangles like shown in the first picture.
3. Extrude the rectangles up by 72mm.
4. Create a chamfer in "two distances" mode and have the two distances be set to 35mm and 72mm.

This is to add reinforcement to the mount.

This step is optional. You may create fillets on the four edges of the part.

1. Create a sketch on the face shown in the picture.
2. Make two 3.1mm or 3.2mm holes on the sketch, spaced 20mm apart, centered horizontally.
3. Extrude the sketch by -6mm in cut operation.

This is the mounting hole that will be used to mount the endstops. The endstops are not actually required but are good for safety.

1. Create a sketch on the same face.
2. Make the sketch like down in the first picture.
3. Extrude it by 2mm outwards.

This is a standoff/spacer for the endstop switches since the components are through-hole and stick through the pcb.

1. Create a 1mm offset plane from the bottom of the mounting hole and create a sketch on that offset plane.
2. Make a hexagon that has 2.35mm side-to-side dimension. Then add a rectangle on top like shown in the picture.
3. Extrude this out by 2.6mm in the cut operation.

This is the nut insert for the endstop mount. Alternatively, you can just make the hole smaller (2.8mm) and directly thread the plastic in, but using an embedded nut is a more elegant solution.

This step is optional. I added more fillets on the top.

1. Create a sketch on the side shown.
2. Make a 54x29mm rectangle in the middle of the sketch like shown. Though keep in mind that a different dimension is required if you're using a different load cell.
3. Extrude the covered part of the rectangle out using the cut operation to create the cutout.
4. Add fillets like shown if needed.

This is the cutout where the load cell will be fitted in.

1. Construct a "plane along path" on the edge shown in the first picture.
2. Create a sketch on that plane and follow the second picture to create the 4.8mm mounting holes.
3. Extrude the sketch in both directions.
4. Create a sketch on the same plane and make 10mm diameter circles.
5. Extrude the sketch upwards.

This is two of the reinforcement holes that will be used to fit the M5x90mm screws. The screws will be directly threaded into the plastic.

1. Create a sketch on top of the part.
2. Draw 4.8mm holes spaced like shown in the picture.
3. Extrude the circles down in cut operation by -82mm.
4. Optionally, you can add chamfers to the holes to perhaps make them a little easier to work with.

These are two more reinforcement holes for the moving load cell mount.

And that's the moving load cell mount done! Two more to go.

1. Create a sketch on the XY Plane and make a 92x60mm rectangle.
2. Extrude the rectangle by 10mm.

This is the moving fixture. It is the part of the machine that is fixed with one end of the testing specimen and one end of the load cell.

1. Create a sketch on the top of the base.
2. Draw the sketch like shown in the picture.
3. Extrude the sketch by 72mm upwards

1. Create a sketch on the face shown.
2. Draw a 16.2mm diameter circle on the sketch, spaced 15mm from the top.
3. Extrude the circle by -20mm.

This is the mounting hole for the load cell. The diameter can be adjusted to fit your load cell.

1. Create a sketch on the face shown.
2. Draw a rectangle like shown in picture.
3. Extrude on both sides like shown.

This is the cutout for the grip blocks.

1. Create a sketch on the face shown.
2. Draw a rectangle like shown in picture.
3. Extrude the two rectangle parts that are inside the solid material out by 45.2mm.

This step is not only for the grip blocks to fit, but also for the screw head to fit.

1. Create a sketch on the inner side of the grips like shown.
2. Draw the sides like shown, keep in mind that this is for a 6mm gap in the middle and that ISO 527-2 1A specimen use 4mm.
3. Extrude the sketch by 26.8mm outwards.
4. (optional) Make a 10mm cutout on the bottom alignment "part".

This so that the grip blocks are better supported and that the specimen can be better aligned.

1. Create a sketch on top of the base.
2. Draw four 3.2mm circles spaced 20mm from each other.
3. Extrude the circles down by 10mm.
4. Create a second sketch on top of the base.
5. Extrude the second sketch up by 41.8mm in the cut operation.

These are the mounting holes for the moving fixture on the linear carriage.

You may add chamfers to the places shown.

1. Create a sketch on the inner side of the grip block cutouts facing outwards.
2. Draw a 12.2mm diameter circle in the middle of the sketch.
3. Extrude that circle in cut operation on both sides.

This is the hole for the clamp screws.

1. Construct a 1.5mm offset plane from the inner side of the grip block cutout.
2. Draw a 9.6mm inscribed hexagon in on that sketch and then a rectangle that extends upwards.
3. Extrude the sketch by -6.3mm.
4. Repeat sub-steps 1-3 on the other side.

This is for the insertion of the M12 low profile nut.

You may add fillets to the part.

This step is optional.

1. Following the sub-steps found in step 22-23, create a the mounting holes.
2. Create small partial chamfers on the edges shown so that nut inserts can be created.

This is for mounting the endstop switch.

Follow the sub-steps in step 24 to make the nut inserts. It works the same way except the rectangles extend downwards.

1. Create a sketch on the face shown.
2. Draw a 14mm circle that is 30mm from the bottom.
3. Extrude the circle by -20mm

Chamfers are then added. This step is optional.

1. Create a sketch on the back of the fixture.
2. Project the bottom of the grip block cutouts onto the sketch.
3. Draw two 4.8mm holes that are spaced 19mm from the edges.
4. Create a sketch on the front of the fixture.
5. Draw 10mm circles on where the mounting holes were.
6. Extrude the circles in by -3mm.

This is for extra reinforcement of the part, mainly so that there will be less flex during a tensile test, which may affect the recorded values.

1. Create a sketch on the XY plane like shown.
2. Extrude the sketch upwards by 10mm.

This is the stationary fixture. It is the part that holds the other end of the specimen in place. Much of the design process for this part is similar to the moving fixture.

1. Create a sketch on the top of the base.
2. Draw the sketch like shown.
3. Extrude by 85mm upwards.

1. Create a sketch on the face shown.
2. Draw a rectangle like shown in picture, spaced 5mm from the top and from the right side.
3. Extrude on both sides like shown.

This is the cutout for the grip blocks.

This step is pretty much repeating the moving fixture.

1. Create a sketch on the inner side of the grip block cutouts facing outwards.
2. Draw a 12.2mm diameter circle in the middle of the sketch.
3. Extrude that circle in cut operation on both sides.

Same process as for the moving fixture.

1. Construct a 1.5mm offset plane from the inner side of the grip block cutout.
2. Draw a 9.6mm inscribed hexagon in on that sketch and then a rectangle that extends upwards.
3. Extrude the sketch by -6.3mm.Repeat sub-steps 1-3 on the other side.

This is for the insertion of the M12 low profile nut.

1. Create a sketch on top of the base.
2. Draw the 5.2mm mounting holes like shown.
3. Extrude them down by 10mm.

Same process as with moving fixture.

1. Create a sketch on the inner side of the grips like shown.
2. Draw the sides like shown, keep in mind that this is for a 6mm gap in the middle and that ISO 527-2 1A specimen use 4mm.
3. Extrude the sketch by 26.8mm outwards.
4. (optional) Make a 10mm cutout on the bottom alignment "part".

This so that the grip blocks are better supported and that the specimen can be better aligned.

Add those chamfers to the sides.

1. Create a sketch on the front face of the part.
2. Draw a 28.2mm circle in the middle, spaced 43mm from the bottom.
3. Extrude the circle inwards by -8mm.
4. Create a second sketch, this time on either the newly created cutout or the front face in between the two mounting holes.
5. Draw the sketch like shown.
6. Extrude the sketch by 8mm outwards.

This is used to hold the 6001 bearing on the other end so that the lead screw can be supported on both ends.

1. Create a sketch on top of the base.
2. Draw 10mm circles on the mounting holes.
3. Extrude the left side part of the sketch up by 5mm.
4. Re-enable the sketch.
5. Extrude the right side part of the sketch up by 2.8mm.

This is just meant for extra reinforcement to the mounting holes.

1. Create a sketch on the top face.
2. Draw a rectangle with dimensions like shown.
3. Extrude that rectangle down by 5mm.

Similar to the original design, a cutout for the top is needed so that the grip blocks can be inserted easily.

1. Create a sketch on the back of the part.
2. Make a 14mm circle in the middle spaced 43mm from the bottom.
3. Extrude the circle by -15mm.

This is a hole for the lead screw to fit through.

Add chamfers and fillets to the parts shown in the pictures.

1. Create a sketch on the inner face of the bearing cutout.
2. Draw a 20mm circle in the middle.
3. Extrude the bottom part of that sketch by 3mm in the direction shown.

Add those extra chamfers/fillets to the part.

1. Create a sketch on the top face.
2. Draw two 5.2mm circles with spacings like shown.
3. Extrude the circles down by -95mm.
4. Create a second sketch on the same face.
5. Draw 10mm circles on where the holes were.
6. Extrude those circles by -10mm.

These are the reinforcement mounting holes using long M5 bolts.

1. Create a sketch on the back face.
2. Draw two 4.8mm circles and two 10mm circles on top of the 4.8mm ones.
3. Extrude the 4.8mm circles by -98mm.
4. Re-enable the same sketch.
5. Extrude the 10mm circle by -8mm on cut operation.
6. Extrude the 10mm circle in the "two sides" mode by -8mm and -20mm on the join operation.

This is for the reinforcement screw, which will directly thread into the plastic.

These chamfers are completely optional and make no real benefit other than cosmetics.

And that's the stationary fixture done!

As these parts are easy to make, this is simply an overview.

The grip block has a smooth side in the front and cutouts on the back. The cutouts are for the reinforcement screws and the T12 clamping screw.

The screw head is a simple torque-extending screw head that can fit onto M12 external hexagon bolts.

This is the design file for the new tensile testing machine in .step format along with each of the design files in f3d format.

Print the parts in the orientations shown in the picture.

The amount required are as follows:

• 1x Stationary Fixture
• 1x Moving Fixture
• 1x Moving Load Cell Mount
• 1x Stepper Motor Mount
• 2x Alignment Tool (Tool 1)
• 4x Grip Block
• 4x Grip Screw Head

It's recommended that the parts be printed with:

• Either 100% rectilinear or >30% gyroid infill.
• 6-8 perimeters/shells.
• A rigid material like PLA or materials of higher rigidity. DO NOT use (regular) PETG.

This section will talk about the selection of components that will be used to build this machine. Some of which are critical to the function of the machine.

The circuit board went through TWO iterations due to malfunctions and magic smoke, so you may see different components in different pictures.

The load cell amplifier is used to amplify and read the data from the strain gauge inside the load cell.

Typically, cheap load cell amplifiers use the HX711 IC made by Avia Semiconductor. It consists of an internal programmable gain amplifier and a 24 bit analog-to-digital converter. Its sample rate is selectable from 10 samples-per-second to 80 samples-per-second, which is important to us.

The main options that one can find for cheap (excluding Sparkfun ones) are typically a red type (shown in first picture), a green XFW-HX711 (not shown), and a green MH-HX711 (shown in second picture).

The part number on those can be confusing, but basically the red type is preferred as long as you use the correct version of the PCB (mentioned later). The reason why is because it has a default 80SPS sample rate and a properly designed circuit, ground plane, and EMI shielding.

• The XFW-HX711 is preferred if you are using the other version of the PCB because it has a selectable sample rate and an acceptable circuit board design.
• The green type shown in the picture is best to be avoided because it is poorly designed and has a non-adjustable sample rate. I will be using this type simply because I have spares of this, but you shouldn't use it. It seems that amazon usually sells this type; however, I would recommend avoiding this type if you can.

The stepper motor driver used in this machine is an A4988 on a StepStick format board. StepSticks are usually used with 3D printers and CNC routers, and therefore they are often easily replaceable.

Any A4988 compatible StepStick drivers will work. This includes DRV8825 and some Trinamic drivers in standalone mode.

There's a wide range of stepper motors that you may choose from. The model that I used is a 42HS6015A4 100:1 planetary geared stepper motor.

Any NEMA 17 planetary geared stepper motor should work as long as the gear ratio is above 20:1.

If the stepper motor shaft has a key, make sure to select a keyed coupler to match that shaft.

The Arduino is used to interface the computer with serial communication and to also control the OLED display.

An Arduino Nano is preferred, although a Nano Every might work too.

The ATTiny85 is used to control the stepper motors so that the pulses will be independent of the main Arduino's processes.

It's preferred to use an 8 pin DIP socket with the ATTiny85-20PU so that if something goes wrong, you can replace the chip without desoldering anything.

This is where you face a choice.

You may choose between an LM7805 or an LM7805 equivalent buck converter. The LM7805 is generally cheaper and produces less noise; however, it also generates around 0.9W of heat in this application, so you may need a heatsink. On the other hand, a buck converter can cost three times as much as the LM7805 but is able to be very efficient and dissipate very little heat.

On the first iteration, I chose a buck converter from Aliexpress. On the second iteration, I chose a buck converter from Murata.

The OLED display needs to be a 128x64 SSD1306 I2C display.

Make sure the polarities are correct.

• Pin headers: use any generic male and female 2.54mm pitch pin headers.
• Terminal block: use KF301 or other connectors with the same pitch.
• Stepper motor/endstop connectors: use XH-2.54 connectors.

This is a tutorial on how to cut the female headers.

You may use a B3F-4000 switch. There are other switches that have the same pinout, but this works well for me.

The passives are much more flexible in terms of selection.

Generally, the capacitors are simply not needed if you're using a quality power supply and a good load cell amplifier. However, they're still recommended.

• Capacitors: use a 100uf >35v electrolytic capacitor for the stepper motor power. In this case I have 100uf 50v lying around, so I'll be using those. You may also want 1210 ceramic capacitors for decoupling (I know that 1210 isn't the best package size, but it's easy to solder).
• Resistors: use 1k-10k resistors. It doesn't matter if they're 1/4W or 1/8W or if they're carbon or wire-wound. As long as they fit the PCB and are in the recommended range, they work just fine. You may also want a 330 ohm resistor for the optional LED.

This is a video assembly animation. Detailed instructions will be below.

1. Place the 2060 aluminum extrusion on a flat surface.
2. Get the stationary fixture and fit the 6001 bearing in the bearing holder. You may need to use a bit of force to get the bearing in, and you may sand the bearing holder to allow for a easier fit.
3. On the back of the fixture, screw in the M5x90mm bolts directly into the plastic into the reinforcement screw holes. Doing so may require a bit of force, but with a proper Allen wrench, this should not be difficult.
4. On the top of the fixture, there should be two nut insertion cutouts. Place M12 low profile nuts in those cutouts.
5. On the top of the fixture, there should be two reinforcement mounting holes. These holes do not require the screw to thread in and should allow the bolts to directly slide in. Slide in the bolts all the way.
6. Slide in M5x14mm bolts on all mounting holes of the stationary fixture.
7. Fit M5 T nuts on all the bolts that were fitted, including the reinforcement mounting bolts. Do not screw the T nuts in all the way because they are meant to rotate and hold on to the aluminum extrusion.

This is a tutorial on how to use T nuts on aluminum extrusions.

This is the hardest part if you don't know much about linear guides (the fancier name for linear rail). Linear rails are precise components, so you want to work with them carefully.

1. First, place the linear rail on the extrusion and align with the printed plastic tool and the cutout in the stationary fixture.
2. If you received your linear rail and carriage block separately, very carefully align the plastic rail it came with to the metal rail. Make sure the carriage does not fall out of a rail (or otherwise you will lose the tiny bearings inside the carriage).
3. Very carefully slide the carriage from the plastic rail on to the real rail, being gentle and correcting any misalignment on the way.
4. Place M3x8 mounting bolts into the rails and use T nuts on the bottom to bolt the linear rail in place.

Linear rail manufacturers often recommend using a datum surface to help align the rail. In this case, precision is not required, and therefore plastic alignment jigs are sufficient.

1. Place the stepper motor mount on the other side of the extrusion.
2. Insert the set of 7201 bearings. Ensure that the direction/setup is correct! Single row angular contact bearings are NOT symmetrical. You want the thicker outer rims to face each other.
3. Mount the stepper motor. Use M3x8mm low profile bolts.
4. Place M5x50mm bolts into the longer holes.
5. Place M5x14mm bolts in the regular mounting holes and use the T nut technique to bolt the assembly down.

1. Place the moving load cell mount on the left linear carriage.
2. Insert and screw in M3x8mm bolts so that the part can be fastened to the linear rail.
3. Place a T12 flanged nut against the "wall" and align it with the mounting holes.
4. Insert M3x22mm bolts and use M3 nyloc nuts to secure the T12 nut.

1. Place the moving fixture on the right linear carriage.
2. Insert and screw in M3x8mm bolts so that the part can be fastened to the linear rail.
3. On top of the moving fixture, there are two nut inserts. Insert M12 low profile nuts in those nut inserts.
4. On the front of the part, there are two reinforcement screw holes. Thread in M5x90mm bolts in those screw holes.

1. Place the load cell in the appropriate position.
2. Use M16x25mm hexagon bolts (or whichever one that fits your load cell) to mount the load cell. Finger tight is enough.

1. (not shown in animation) Apply 40 grit sandpaper or grip tape onto the grip blocks. Use super glue or strong epoxy to glue down the sandpaper.
2. Slide in the grips one by one into their cutouts.
3. Screw in the M12x50mm external hexagon bolts.
4. Push the grip screw head onto the external hexagon bolts. It should have a tight fit if printed properly.

1. Place a coupler on the stepper motor but don't tighten the screws down yet.
2. Slide in the load cell from the hole in the stationary grip all the way to the bearing blocks.
3. Position the shaft collars on the bearing and have the raised edge face the bearing. There should be two shaft collars, one on each side of the bearing block.
4. Slide the lead screw into the shaft collars and out the other side into the coupler.
5. Tighten down the coupler as hard as you can. Use a long allen wrench for this to apply the maximum amount of force you can exert (without stripping the screw).

And that is the physical assembly done! Your machine should look something like the pictures here (except for the electronics).

This section focuses on the electronics assembly of this machine.

The circuit board went through TWO iterations due to malfunctions and magic smoke, so you may see different components in different pictures.

This is the schematic for the PCB.

The PCB and its Gerber files are on my GitHub repository because Instructables does not allow .zip files to be uploaded.

There are two PCB types available. If you are building this from scratch, choose the red one. If you already have green HX711s, choose the green one.

You may manufacture this PCB through fabrication houses such as JLCPCB, PCBWay, DirtyPCBs, OSHPark, and many more.

The assembly process is pretty straightfoward. Simply solder the required components onto the board and plug in the parts. Make sure to double and triple check the polarity and component orientation or else magic smoke will escape (it happened for me, but don't worry, the problem is fixed).

On the newer version of the PCB, you will see a place for adding a diode. You can either bridge the jumper on that part using a solder bridge or add the diode. If you choose to not populate the diode and instead use a solder bridge, you must desolder the USB diode on the Nano to avoid overcurrent on the USB. Keep in mind that USB power itself cannot power the whole board due to excessive capacitance.

I also recommend adding a schottky diode in series with the power source to ensure that no reverse polarity can happen.

Once again, the code can be found on GitHub.

This is the Arduino master code:

/*
Universal Tensile Testing Machine Code By Xieshi aka CrazyBlackStone
VERSION 2.1.1 REV 3
Designed for use with custom PCB
Project published under CC-BY-NC-SA license https://creativecommons.org/licenses/by-nc-sa/4.0/
*/

//Need Wire library. It should come preinstalled with Arduino IDE.
#include <Wire.h>
 
//Need HX711 library https://github.com/bogde/HX711
#include <HX711.h>

//Need U8x8 library, which is included in the u8g2 library https://github.com/olikraus/u8g2
#include <U8x8lib.h>

//----------USER PARAMETERS----------

//PLX-DAQ - Excel data collection. Uncomment this if you have PLX-DAQ set up for data analysis.
//#define plxdaq

//Calibration setup: if you know your load cell's calibration factor, uncomment and change the calibration factor below. If you don't want to calibrate the load cell, comment this out.
#define calibration

#define calibrationFactor 1.9305 * 2280 * 0.09806// this value is obtained by calibrating the scale with known weights, details in https://github.com/bogde/HX711

//set this to the basic steps per revolution of your stepper motor (not counting in gear ratio). It is 200 for 1.8 degree stepper motors and 400 for 0.9 degree stepper motors. Leave unchanged if you don't know - in most cases it is 200 steps per rev.
#define stepsPerRev 200
//set this to the microstepping setting. This does not control the microstepping of the driver - it simply sets the step rate. Set the microstepping mode in hardware through the MS pins.
#define microStep 16
//set this to the gear ratio of the stepper motor you're using
#define gearRatio 100
//set this to the lead screw lead you're using
#define leadScrewPitch 8
//don't change this unless you want to change the modulus start speed
#define modulusSpeedMultiplier 25
//don't change this unless you want to change the slow speed
#define slowSpeedMultiplier 50
//don't change this unless you want to change the fast speed
#define fastSpeedMultiplier 100
//modulus test threshold. Used to determine when to change speed to fast.
#define modulusThreshold 30000
//reading attempts to be taken on each reading; the average of the attempts will be displayed. Depends on your load cell amplifier's configuration. 10hz - 1 attempt, 80hz - 8 attempts.
#define readAttempts 1
 
//pin definitions
#define EStopPin 2
#define tarePin 3
#define moveUpPin 4
#define modePin 5
#define startPin 6
#define moveDownPin 7
#define ledPin 8
#define endStop1Pin 9
#define endStop2Pin 10
#define enablePin 13
#define DTPin A0
#define SCKPin A1
#define dCalDTPin A2
#define dCalSCKPin A3

//parameters
bool testStart = false;
bool moveStepper = false;
byte stepperDir = 0;
byte stepperStatus = 0; //0 = stopped, 1 = moving
int multiplier = 1;
#define modulusSpeed stepsPerRev * microStep * gearRatio / leadScrewPitch / 60 * modulusSpeedMultiplier
#define slowSpeed stepsPerRev * microStep * gearRatio / leadScrewPitch / 60 * slowSpeedMultiplier
#define fastSpeed stepsPerRev * microStep * gearRatio / leadScrewPitch / 60 * fastSpeedMultiplier
int stepperSpeed = slowSpeed;
byte stepperSpeedHigh;
byte stepperSpeedLow;
#define slowMeasurementDelay 0.8 * 1000000
#define fastMeasurementDelay 0.1 * 1000000
float measurementDelay = slowMeasurementDelay;
float measurementMax = 0;
unsigned long lastMeasurement = 0;
unsigned long testStartTime = 0;
unsigned long testTime = 0;
byte mode = 1; //1 - tensile slow, 2 - tensile fast, 3 - compression slow, 4 - compression fast, 5 - modulus
bool modeOldState = HIGH;
bool startOldState = HIGH;
bool tareOldState = HIGH;
bool moveUpOldState = HIGH;
bool moveDownOldState = HIGH;
bool confirmMode = false;
bool emergencyStop = false;
String stringMode;

U8X8_SSD1306_128X64_NONAME_HW_I2C u8x8(/* reset=*/ U8X8_PIN_NONE);   
HX711 scale;
 
void setup() {
  Serial.begin(9600);
  Wire.begin();
  #ifndef plxdaq
  Serial.println(F("INITIALIZING"));
  #endif

  u8x8.begin();
  u8x8.setPowerSave(0);
  u8x8.setFont(u8x8_font_inr21_2x4_r);

  u8x8.setCursor(0,0);
  
  scale.begin(DTPin, SCKPin);
 
  #ifdef calibration
  scale.set_scale(calibrationFactor); 
  #endif
 
  scale.tare(20);

  pinMode(moveUpPin, INPUT);
  digitalWrite(moveUpPin, HIGH);

  pinMode(moveDownPin, INPUT);
  digitalWrite(moveDownPin, HIGH);

  pinMode(modePin, INPUT);
  digitalWrite(modePin, HIGH);

  pinMode(startPin, INPUT);
  digitalWrite(startPin, HIGH);
  
  pinMode(tarePin, INPUT);
  digitalWrite(tarePin, HIGH);

  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);
  
  pinMode(EStopPin, INPUT);
  digitalWrite(EStopPin, HIGH);

  pinMode(enablePin, OUTPUT);
  digitalWrite(enablePin, LOW);
  
  pinMode(endStop1Pin, INPUT);
  digitalWrite(endStop1Pin, HIGH);

  pinMode(endStop2Pin, INPUT);
  digitalWrite(endStop2Pin, HIGH);

  attachInterrupt(digitalPinToInterrupt(EStopPin), stopNow, FALLING);

  #ifndef plxdaq
  Serial.println(F("INITIALIZATION COMPLETE"));
  #else
  Serial.println(F("CLEARDATA"));
  Serial.println(F("LABEL,Time,Test Time,Value"));
  #endif
}
 
void loop() {

  //EMERGENCY STOP
  if (!digitalRead(endStop1Pin) || !digitalRead(endStop2Pin) && !emergencyStop)
  {
    stopNow();
    Serial.println(F("Endstop triggered - emergency stop"));
  }
  
  if (emergencyStop)
  { 
    stepperSpeed = 0;
    stepperDir = 0;
    stepperStatus = 0;
    sendCommand();
    
    Serial.println(F("\n\n\n-EMERGENCY STOP - RESET TO CLEAR-\n-EMERGENCY STOP - RESET TO CLEAR-\n-EMERGENCY STOP - RESET TO CLEAR-"));
    u8x8.clear();
    u8x8.print(F("E-STOP\nRESET"));
    for (;;);
  }
  
  String inputString;
  bool serialAvailable = false;
  while (Serial.available())
  {
    serialAvailable = true;
    inputString = Serial.readString();
    inputString.toLowerCase();
  }
  if (serialAvailable)
  {
    if (inputString == "start")
    {
      checkMode();
      Serial.println("Current mode is: " + stringMode + ". Confirm? Y/N");
      confirmMode = true;
    }
    else if (inputString == "stop")
    {
      stopTest();
    }
    else if (inputString == "tare")
    {
      tareScale();
    }
    else if (inputString == "up")
    {
      moveUp();
    }
    else if (inputString == "down")
    {
      moveDown();
    }
    else if (inputString == "mode")
    {
      changeMode();
    }
    else if (inputString == "y" && confirmMode)
    {
      startTest();
    }
    else if (inputString == "n" && confirmMode)
    {
      confirmMode = false;
      Serial.println(F("\n-TEST CANCELLED-\n"));
    }
    else
    {
      Serial.println(F("Unknown Command"));
    }
  }
  
  bool modeNewState = digitalRead(modePin);
  bool moveUpNewState = digitalRead(moveUpPin);
  bool moveDownNewState = digitalRead(moveDownPin);
  bool startNewState = digitalRead(startPin);
  bool tareNewState = digitalRead(tarePin);
  
  if (!digitalRead(moveUpPin) && moveUpNewState != moveUpOldState && moveUpNewState == LOW)
  {
    moveUp();
  }
  else if (!digitalRead(moveDownPin) && moveDownNewState != moveDownOldState && moveDownNewState == LOW)
  {
    moveDown();
  }
  else if (!digitalRead(modePin) && modeNewState != modeOldState && modeNewState == LOW && !testStart)
  {
    changeMode();
    delay(10);
  }
  else if (!digitalRead(startPin) && startNewState != startOldState && startNewState == LOW)
  {
   if (!testStart && !moveStepper)
   {
     startTest();
   }
   else
   {
     stopTest();
   }
   delay(10);
  }
  else if (!digitalRead(tarePin) && tareNewState != tareOldState && tareNewState == LOW)
  {
   tareScale();
   delay(10);
  }
 
  modeOldState = modeNewState;
  startOldState = startNewState;
  moveUpOldState = moveUpNewState;
  moveDownOldState = moveDownNewState;
  tareOldState = tareNewState;

  testTime = millis() - testStartTime;

  if ((micros() - lastMeasurement) >= measurementDelay)
  {
    float measurement = scale.get_units(readAttempts) * multiplier;
    String measurementStr = String(measurement);
    #ifndef plxdaq
    Serial.println(measurementStr);
    #endif
    
    if (!testStart)
    {
      String modeStr = String(mode);
      u8x8.clear();
      u8x8.println(measurementStr + "\nMode: " + modeStr);
    }
    else
    {
      if (measurement >= measurementMax)
      {
        measurementMax = measurement;
      }
      #ifdef plxdaq
      String testTimeStr = String(testTime);
      String millisStr = String(millis());
      Serial.println("DATA,TIME," + millisStr + "," + testTimeStr + "," + measurementStr);
      #endif
    }
    lastMeasurement = micros();
  }

  if (mode == 5 && testTime >= modulusThreshold && stepperSpeed != fastSpeed)
  {
    Serial.println(F("THRESHOLD REACHED"));
    stepperSpeed = fastSpeed;
    stepperDir = 0;
    multiplier = 1;
    stepperStatus = 1;
    sendCommand();
  }
}
 
 
void startTest()
{
  confirmMode = false;
  moveStepper = true;
  //digitalWrite(enablePin, LOW);

  Serial.println(F("\n-TEST START-\n"));

  scale.tare(20);
  measurementDelay = fastMeasurementDelay;
  if (mode == 1)
  {
    stepperSpeed = slowSpeed;
    stepperDir = 0;
    multiplier = 1;
  }
  else if (mode == 2)
  {
    stepperSpeed = fastSpeed;
    stepperDir = 0;
    multiplier = 1;
  }
  else if (mode == 3)
  {
    stepperSpeed = slowSpeed;
    stepperDir = 1;
    multiplier = -1;
  }
  else if (mode == 4)
  {
    stepperSpeed = fastSpeed;
    stepperDir = 1;
    multiplier = -1;
  }
  else if (mode == 5)
  {
    stepperSpeed = modulusSpeed;
    stepperDir = 0;
    multiplier = 1;
  }

  stepperStatus = 1;
  sendCommand();
  
  testStart = true;
  measurementMax = 0;
  testStartTime = millis();

  u8x8.clear();
  u8x8.println("Test\nStarted");
}
 
void stopTest()
{
  Serial.println("\n-STOP-\n");
  measurementDelay = slowMeasurementDelay;

  stepperSpeed = 0;
  stepperDir = 0;
  stepperStatus = 0;
  sendCommand();
  
  moveStepper = false;
  //digitalWrite(enablePin, HIGH);
  
  if (testStart)
  {
    u8x8.clear();
    String measMaxStr = String(measurementMax);
    u8x8.println("Max: \n" + measMaxStr);
    #ifndef plxdaq
    String testTimeStr = String(testTime);
    Serial.println("Time: " + testTimeStr + "\nMaximum value: " + measMaxStr); 
    #endif
    testStart = false;
    delay(10000);
  }
}

void tareScale()
{
  Serial.println(F("\n-SCALE TARE-\n"));   
  scale.tare(20);
}

void moveUp()
{
  moveStepper = true;
  //digitalWrite(enablePin, LOW);
  Serial.println(F("\n-MOVING UP-\n"));

  stepperSpeed = fastSpeed;
  stepperDir = 0;
  stepperStatus = 1;
  sendCommand();
}

void moveDown()
{
  moveStepper = true;
  //digitalWrite(enablePin, LOW);
  Serial.println(F("\n-MOVING DOWN-\n"));

  stepperSpeed = fastSpeed;
  stepperDir = 1;
  stepperStatus = 1;
  sendCommand();
}

void changeMode()
{
  if (mode < 5)
  {
    mode++;
  }
  else
  {
    mode = 1;
  }
  checkMode();
  Serial.println("CURRENT MODE: " + stringMode);
}

void checkMode()
{
  if (mode == 1)
  {
    stringMode = F("SLOW Tensile Test");
  }
  else if (mode == 2)
  {
    stringMode = F("FAST Tensile Test");
  }
  else if (mode == 3)
  {
    stringMode = F("SLOW Compression Test");
  }
  else if (mode == 4)
  {
    stringMode = F("FAST Compression Test");
  }
  else if (mode == 5)
  {
    stringMode = F("Tensile Modulus Test");
  }
}

void stopNow()
{
  digitalWrite(enablePin, HIGH);
  //pinMode(EStopPin, OUTPUT);
  //digitalWrite(EStopPin, LOW);
  
  moveStepper = false;
  emergencyStop = true;
}

void sendCommand()
{
  stepperSpeedHigh = *((uint8_t*)&(stepperSpeed)+1);
  stepperSpeedLow = *((uint8_t*)&(stepperSpeed)+0);
  byte sendInfo[4] = {stepperSpeedHigh, stepperSpeedLow, stepperDir, stepperStatus};
  Wire.beginTransmission(9);
  for (int i=0; i<4; i++)
  {
    Wire.write(sendInfo[i]);  //data bytes are queued in local buffer
  }
  byte sendStatus = Wire.endTransmission();
  if (sendStatus != 0)
  {
    String sendStatusStr = String(sendStatus);
    Serial.println("Send failed (" + sendStatusStr + ")- emergency stop");
    stopNow();
  }
}<br>

ATTiny slave code

/*
Universal Tensile Testing Machine ATTiny85 Code By Xieshi aka CrazyBlackStone
VERSION 2.1.1 REV 2
Designed for use with custom PCB
Project published under CC-BY-NC-SA license https://creativecommons.org/licenses/by-nc-sa/4.0/
Code published under GNU General Public V3 https://www.gnu.org/licenses/gpl-3.0.en.html
*/

//Need TinyWireS library https://github.com/rambo/TinyWire
#include <TinyWireS.h>

//pin definitions
const int stepPin = PB3;
const int dirPin = PB4;

//parameters
bool moveStepper;
unsigned long lastStep = 0;
int stepperSpeed = 1000;
int dataArray[3];

void setup() {
  TinyWireS.begin(9);
  pinMode(stepPin, OUTPUT);
  digitalWrite(stepPin, LOW);
  pinMode(dirPin, OUTPUT);
  digitalWrite(dirPin, LOW);
}

void loop() {
  while (TinyWireS.available())
  {
    for(int i=0; i<4; i++)
    {
      dataArray[i] = TinyWireS.read();
    }
    stepperSpeed = ((dataArray[0]<<8)+dataArray[1])/10;
    if (dataArray[2] == 0)
    {
      digitalWrite(dirPin, LOW);
    }
    else if (dataArray[2] == 1)
    {
      digitalWrite(dirPin, HIGH);
    }
    if (dataArray[3] == 0)
    {
      moveStepper = false;
    }
    else if (dataArray[3] == 1)
    {
      moveStepper = true;
    }
  }
  if (moveStepper)
  {
    if ((micros() - lastStep) >= 1000000. / stepperSpeed)
    {
      digitalWrite(stepPin, HIGH);
      delayMicroseconds(5);
      digitalWrite(stepPin, LOW);
      delayMicroseconds(5); 
      lastStep = micros();
    }
  }
  TinyWireS_stop_check();
}

These are the parameters that need to be set before you upload the code.

PLX-DAQ Excel Data Acquisition

This parameter can be enabled if you will use PLX-DAQ to acquire and analyze the data. The integration of PLX-DAQ is requested from a comment from the original tensile testing machine's instructable.

You need to set up PLX-DAQ in Excel to be able to record the data. I have NOT tested this, so I don't actually know if this setup will work or not. But for those who are interested in using PLX-DAQ, this is an option that probably works.

Calibration Factor

Each load cell has a different calibration factor. You will need to calibrate your own load cell using a known weight through Bogde's instructions.

Steps Per Revolution

1.8 degree stepper motors have 200 steps per revolution, while 0.9 degree stepper motors have 400 steps per revolution. Set this parameter to the value corresponding to your stepper motor.

Microstepping

The microstepping value depends on the microstepping jumpers you set for the stepper motor driver. Set the value corresponding to the microstepping value.

Lead Screw Pitch

I'm using a 2mm pitch and 8mm lead lead screw. Therefore, the pitch I set here is 8mm because the nut moves 8mm per revolution. You may have a lead screw with a different pitch.

Speed Multipliers

Set this to the speed that you wish to test the specimens at.

Modulus Threshold

This is the time threshold in milliseconds you wish to have the modulus test mode turn into fast mode.

Read Attempts

This purely depends on the sample rate of your load cell amplifier. If you're using the red HX711 or one that is set to 80SPS, use 8 for the read attempt number. Otherwise, leave it at 1.

1. To program the Arduinos, plug in the Arduino Nano to the computer, or if you've desoldered the diode, use the board power and connect the Arduino Nano to the computer. Upload the example ArduinoISP sketch onto the board using AVR ISP Mk2 or your programmer of choice. This ArduinoISP sketch can be found under Examples -> ArduinoISP.
2. Then, find the four jumpers (U5), and connect the pins together using jumper wires or premade jumpers.
3. Now, you will need the ATTinyCore board library. Follow the instructions on GitHub to install it. You will also need the following libraries: TinyWireS, HX711, and u8g2.
4. Connect the board power if you haven't already.
5. Burn the bootloader (OptiBoot) to the ATTiny85.
6. Upload the ATTiny_Code.ino using the ATTiny85 (OptiBoot), 1mhz clock (16mhz PLL also works according to comments), and Arduino as ISP programmer.
7. Before you upload the main Arduino code, check the parameters and make sure they are set correctly. This includes the calibration factor, speeds, and other parameters.
8. Then upload the Main_Simplified_Code.ino using Arduino Nano and AVR ISP Mk2 or your preferred programmer.
9. At this time, you may disconnect the programming jumpers. I2C will not work until you disconnect the jumpers.
10. Finally, to choose the microstepping settings of the stepper motor driver, connect MS1, MS2, and MS3 based on the microstepping table given in the A4988 datasheet.

Operating Modes

There are five main testing modes that are available in this machine:

1. Slow tensile test
2. Fast tensile test
3. Slow compression test
4. Fast compression test
5. Modulus test

The names themselves are self-explanatory except for modulus test. This test mode is inspired from CNC Kitchen and his tensile testing machine, which has a modulus test mode. Basically, the machine will start slow for a set amount of time and then do a fast test after the time threshold is reached. I have not tested the modulus mode on this machine, but it should work.

Starting a Test

You first need to load the specimen onto the machine. The default type of specimen used here is ISO 527-2 1A or ASTM D638-II. These specimens are less than 6mm thick, meaning that the best practice is to use a jig to align the specimens. Subtract the thickness of the specimen from 6mm, and that's jig thickness you'll need. Make the jig in Tinkercad or Fusion 360 and then 3D print it to use.

There are two ways to start the test once you've loaded the samples: through the button on the PCB or through the computer. Both ways work and both will record the ultimate tensile strength as long as the OLED display is installed.

Computer:

If you choose to use the computer, this is a list of commands:

• mode - switches between each mode
• start - starts the test, you'll need to confirm the mode by entering "y"
• stop - stops the test/movement, it'll display the maximum value if the action stopped was a test
• up - moves up
• down - moves down

To start a test on the computer, first choose the mode by using the "mode" command. Then use the "start" command to start the test. There will be a prompt asking you to confirm the mode; enter "y" to confirm. Once the test is finished, enter "stop" to stop the test.

Buttons:

The other way to start the test is to use the buttons on the PCB. The silkscreen on the PCB explains what the buttons do, and their functions are similar to the computer's commands, with the only difference being that no confirmation is needed to start the test.

This is an extremely poorly made video showing the machine work. I did not show the data being recorded, but trust me, it does work.

Also, the camera shake in the end was due to me being "startled" by the specimen breaking. I was nervous that something was going to break at the time, which was why there is the shake in the end.

I might try and make a new video.

So many steps! I'm so glad that you made it to the end.

This is likely the final version of the tensile testing machine project, so feel free to build it! If have any questions, comment below or leave me a message. I might publish this on Thingiverse as well (though I'm not quite certain). The content will be the same except the design process won't be included.

I'd like to thank those who gave me feedback on the last tensile testing machine, Maker Hub Club for providing funding, my friend for helping me in the original design, CNC Kitchen for inspiration, and YOU for reading this instructable.

Thank you and have a great day!