3D Printed Construction Set Parts

Toy construction sets are great for getting creative, but often have limitations in available number or type of parts. Making custom or additional 3D printed construction set parts as an extension to you construction set allows for more interesting and larger projects to be achieved with your set.

For example, I had a shortage of long bars to make a scissors mechanism. I designed and 3D printed the lacking parts and could finally advance with my distance pinching fun project. :D Being able to make my own additional parts felt so empowering that I wanted to share how to do it with you.

In this tutorial, I’ll give step-by-step instructions to enable you to design additional 3D printed construction set parts to expand your set. I’ll show it based on the construction set I have as an example, but the general principle is similar for other construction sets.

For designing the parts, we will be using the free Playground version of trCAD by trinckle. You can use it directly in the browser without a login. trCAD is a scripted CAD software in a C-like language, very easy to learn for people with basic coding experience, but even if you have not written a single line of code before, this tutorial will be simple enough to follow along. All you have to do is copy and paste code snippets.

1. Calipers or ruler
2. Original part of your construction set
3. 3D-printer or 3D-printing service

Start with a part that is not too complicated to get started. It is easiest to start with something that is similar to a part you already have in the set but you need more of these parts or want to have a little variation of that part. If you feel more confident you can advance to more complex parts later.

In my case, I was short of the long bars (pun intended!) to make the scissors mechanism I had in mind. I took an already existing bar from my set as a reference part for re-designing it and wanted to allow for a free-to-choose length. Longer is better for scissor mechanisms if you plan to pinch your foes from the distance. :-D

To blend additional parts smoothly into your existing set, you first have to understand the functionality of the original reference part. Especially the size of and distances between interfaces like screw holes or feedthroughs are usually an important factor. For some type of parts, the outer dimensions are important as well (brick-style parts), whereas for other types the outer dimensions are more forgiving when it comes to exactness (e.g. bar-style parts).

Let’s start with defining which features and measurements of the reference part are a must-have for our additional parts, which are desirable and which we can as well skip.

In my example, I have a flat bar with screw holes, that roughly looks like in the drawing.

The must-have features and measurements are these:

1. Screw holes with a certain diameter
2. Certain distance between screw holes
3. Certain thickness of the bar (at least roughly)

Generally, any part with matching values for these three measurements could be compatible with my construction set to some extent.

Not strictly needed, but I want my additional parts to have the same stadium shape as the reference part to avoid collisions for rotations. In addition, I want the additional parts to follow the original aesthetics roughly as well, which can be achieved by including the same small, stadium shaped clearance holes.

Therefore, desirable features and measurements for my parts are these:

1. Stadium shape of the outline
2. Certain width of the bar
3. Small, stadium shaped clearance holes between the screw holes with a certain size

There are more subtle design features for the reference part that I did not include in the drawing, like shallow rings around the screw holes that have a slight effect on reducing friction for rotations and grooves similar to the small stadium holes to save on material. But these features are not crucial for the parts and would complicate the 3D-printing process by introducing the need of support structure. Therefore, I skip these features for keeping it simple yet functional.

Using the calipers results in more accuracy, but in case you do not have one, a good ruler can do the trick as well. For the flat bar, I needed to do six measurements that came out like this:

1. Width of the bar = 22.4 mm
2. Screw hole diameter = 9.8 mm
3. Distance between screw holes = 22.0 mm
4. Full length of the small holes = 10.4 mm
5. Width of the small holes = 4.1 mm
6. Thickness of the bar = 4.0 mm

It is a good idea to break down the construction into steps for being sure that we have a clear idea what needs to be done and for handling complexity. For the additional parts of this example, I identified 6 steps:

1. Define the part’s outline curve as a stadium curve
2. Add thickness to the outline curve by extruding (using an arbitrary value for the length)
3. Define the actual value for length for a custom number of screw holes
4. Define and position the screw hole curves
5. Define and position the small hole curves
6. Adding final touches

Now we have actionable construction steps and can advance implementing each of them one by one. But first, let’s make a quick dive into the workflow using the trCAD Playground.

Before we start implementing our construction using the trCAD Playground, let’s take a moment to get familiar with its workflow.

Visit https://playgroundapp.trcad.trinckle.com/ to access the trCAD Playground app.

On the left side you can type your code. On the right side you will see the 3D result of the code. After making changes to the code, hitting the button run code will apply the changes to the result.

For a first test, let’s quickly make a box with customizable height to get familiar with the workflow.

Copy this code sample into the code editor of the Playground:

open float height
{
  name  = "Height"
  descr = "Height of the box"
  value = 10
}
make box( 30, 20, height )

and hit the run code button.

On the right side, a 3D box appears that you can turn by clicking and holding and move by right-clicking and holding. In addition, you will see an input field in the Customize container for setting the height parameter. Change the height in the input field to see what happens.

If you feel the parameter customizing container is in the way, you can minimize it by clicking the left arrow in its heading and later maximize again by hitting the parameter symbol.

Congratulations, you made a Customizer! 🎉

After this first test, you are ready to get started with implementing the actual custom part. Delete the test code or reload the Playground for a fresh start before advancing.

With a clear plan of construction steps and the measurements needed, let’s start implementing the part using the trCAD Playground. Note that the Playground does not have the capability to save your files. It is a good idea to save your progress in a separate text file in your favorite text editor.

In case you get lost on the way do not worry, I attached the full code at the end of this tutorial.

Construction Step 1: Define the part’s outline curve as a stadium curve

Let’s have a look at the drawing image to understand the stadium curve:

We see that a stadium curve consists of two straight lines connected by two half-circle arcs on each side. We let the curve start at point 1 and set that point to be at the 2D-coordinate origin <[0,0]> in trCAD notation. Then the curve goes to point 2 in a straight line, then to point 3 following a half-circle arc, then to point 4 in a straight line and finally back to point 1 following a half-circle arc.

Note that we define the curve to go counter-clockwise around the shape. That is important, because only for a counter-clockwise curve the extrusion will add material, for a clockwise curve it would add a hole. (Background is a mathematical convention used in CAD as well: counter-clockwise orientation is mathematically positive, while clockwise means mathematically negative. I know – mind-bending! Feel free to issue a complaint to your local mathematician!)

The dimensions of the stadium depend on two values: the length of the straight lines and the width of the stadium. Note that the width of the stadium is identical to the diameter, and therefore double the radius of the arcs.

Since we will be needing a stadium-shaped curve for both, the outline of the part and the small holes, we put the stadium curve in a function for being able to re-use it.

This is how the code for the stadium curve function looks like:

function CurveStadium( float straightLen, float width )
{
  float radiusStadium = 0.5 * width
  curve curveStadium = <[0.0, 0.0]> -> 
                       <[straightLen, 0.0]> ->
                       arc_to( <[straightLen, width]>, radiusStadium ) ->
                       <[0.0, width]> ->
                       arc_to( <[0.0, 0.0]>, radiusStadium) -><-
                   
  return curveStadium
}

We use curve links -> to chain curve segments and explicitly close the curve at the end using the closure operator -><-.

Copy the above code into the Playground. But when hitting run code no output is generated. Why? Because in the output only 3D results are shown and we only defined a function for generating a 2D curve until now.

Let’s change that in the next step.

Construction Step 2: Add thickness to the outline curve by extruding

Until now we only defined a function to give us back a stadium curve, now let’s use that function for defining our part outline curve.

We will already be taking the correct values for part width (22.4 mm) and part thickness (4.0 mm) from the measurements, but for the straight length we will just take some arbitrary value for now (e.g. 100 mm), later calculating the exact value based on the number of screw holes.

Add the following code directly below the code you already have in the Playground editor:

float widthPart = 22.4
float thickPart = 4.0

float straightLenPart = 100

curve outline = CurveStadium( straightLenPart, widthPart )

vector extrudeDir = <[0, 0, thickPart]>

color col = rgb(255,255, 92)

make col >> extrusion( outline, extrudeDir)

We defined the extrusion to go into z-direction with the thickness we want to have for the part, using <[0, 0, thickPart]> as the direction vector for extrusion. In addition, we applied a nice yellow color to the part, defining a RGB color variable and applying it to the result of our extrusion by using the apply operator >>. The make command tells trCAD to add the result to the 3D output.

Hitting run code now generates the extruded 3D output and you should see something like in the attached image.

Now we have already a nice draft for the outline, next let’s tackle defining the correct length.

Construction Step 3: Define the actual value for length for a custom number of screw holes

We want the length to automatically adapt to fit the desired number of screw holes. Having a look at the drawing for the example of 4 holes, this is pretty easy to define.

The straight length of the stadium is 3 times the distance between screw hole centers for 4 holes, and for 5 holes we would need to add one such distance ending up with 4 distances. For a custom number of screw holes n, we need (n-1) distances between screw hole centers.

So, what we need to do is defining a variable for the number of screw holes and a variable for the distance between screw hole centers and from that calculate the correct straight length for the outline curve.

We have measurements for the distance between the borders of the screw holes (22.0 mm) and for the screw hole diameter (9.8 mm). For getting the distance between screw hole centers, we just have to add double the screw hole radius to the distance between borders, or easier, just adding once the diameter of the screw holes to the distance between borders.

In code, this is how it looks:

float diaHoles = 9.8
float distHolesBorder = 22.0

open int nHoles
{
  name = "Hole number"
  descr = "The number of holes of a construction bar."
  value = 3
  min = 2
  max = 10
}

float distHolesCenter = distHolesBorder + diaHoles
float straightLenPart = ( nHoles - 1 ) * distHolesCenter

We directly defined the number of holes as an open parameter, settable by the user. You could of course define it as a normal variable and change it in the code to the value you like, but defining it as an open parameter makes it more convenient to change later, you can define limits for min and max, e.g. less than 2 makes no sense and if you already found out that a bar with more than 10 holes will not fit on your printer’s platform, setting this as a max is a good idea. Usage of open parameters allows for generating customizers and even a person with no knowledge of your code could use this customizer with ease.

Copy the code above into the Playground editor replacing the following line of the old code:

float straightLenPart = 100

After hitting run code, the screen should look like in the image attached, with settable number of holes as an input field.

After we have achieved this dynamic calculation of the length, let’s advance to the next steps, adding screw holes.

Construction Step 4: Define and position the screw hole curves

Having a look at the drawing shows how we can define the screw holes:

For the first screw hole, the curve starts from point 1, that lies one screw hole radius in x-direction and half the bar width in y-direction away from the origin. From that point, the curve goes around one full circle (2 x Pi in radians), the center of the circle being directly half the bar width above the origin.

For each hole, we shift the hole curve into x-direction by the distance between the screw centers we already calculated for the step before.

For being able to combine the curves for the screw holes with the outline curve, we introduce a sketch in our code and extrude that sketch. A sketch can hold a set of curves, we start with the outline and subtract each hole curve iteratively (subtracting inverts the orientation of a curve, telling trCAD to generate a hole in the extrusion for the corresponding curve).

This is how the new code part looks like:

diaHoles = diaHoles + 0.2 // make slightly bigger to ensure fitting of screw

vector centerScrewHole = <[0.0, widthPart * 0.5]>
curve screwHole = <[diaHoles * 0.5, widthPart * 0.5]> -> arc( centerScrewHole, 2PI )

sketch sketchPart = outline
for( int n = 0; n < nHoles; n++ )
{
  atrafo shift = translation( <[n * distHolesCenter, 0.0]>)
  sketchPart = sketchPart - shift >> screwHole
}
make col >> extrusion( sketchPart, extrudeDir )

For going through the holes, shifting each to the correct place and subtracting it from the sketch, we use an iterative for loop. This just tells trCAD to do a set of operations a defined number of times, for each turn adding 1 to the number of holes it already went through and stopping when it reached the defined number of rounds.

It is common practice to start counting from 0 instead of 1 and stopping one number earlier respectively, which is as well handy in our case because it will then just not shift the first hole (shifts by a zero distance).

Copy the above code, replacing the last line of the old code.

After hitting run code, the part now has the screw holes added.

This part now would already technically work as an added part for the set. But we want to make it a better fit from the aesthetics and saving a bit on weight of the part as well. Maybe there is a creative way for feeding trough ropes or something like that, so let’s tackle the last construction step and add the small elongated holes.

Construction Step 5: Define and position the small hole curves

We already have our function for generating stadium-shaped curves. We will use this for the small holes as well. Let’s have a look at the drawing showing how to define the small holes:

The straight length needed for the stadium curve is the full length we have a measurement for minus two times the radius of the small hole, or simplified, the full length minus once the width of the small hole.

Using our stadium curve function will give us a curve with first point at the origin. For the first small hole, we want that point to be shifted like can be seen on the drawing image. In x-direction we can imagine the shift to go half the distance between screw hole centers forward and after that half the straight length of the small hole backwards again, therefore moving the difference of these two values in x-direction. Similarly, in y-direction, the shift goes half the bar width up and after that half the small hole width down again.

After positioning the first small hole, we then place each small hole shifted by the same amount as the screw holes, so in each iteration for the screw holes we add one small hole to the right. But we have to stop one round earlier because there is no small hole right to the last screw hole.

In code, the changed parts look like this:

float fullLenSmallHoles = 10.4
float widthSmallHole = 4.1

float straightLenSmallHoles = fullLenSmallHoles - widthSmallHole

curve smallHole = CurveStadium( straightLenSmallHoles, widthSmallHole )
smallHole = translation( 0.5 * <[ distHolesCenter - straightLenSmallHoles,
                                  widthPart - widthSmallHole ]> ) >> smallHole
                   

sketch sketchPart = outline
for( int n = 0; n < nHoles; ++n )
{
  atrafo shift = translation( <[n * distHolesCenter, 0.0]>)
  sketchPart = sketchPart - shift >> screwHole
  if( n + 1 < nHoles )
    sketchPart = sketchPart - shift >> smallHole
} 

Copy the above code, replacing the following part of the old code:

sketch sketchPart = outline
for( int n = 0; n < nHoles; n++ )
{
  atrafo shift = translation( <[n * distHolesCenter, 0.0]>)
  sketchPart = sketchPart - shift >> screwHole
}

After hitting run code now, the part has small holes in addition and the screen should look like on the image attached.

After we came until here, let’s add some finishing touches for making it look nicer and get smooth edges.

Construction Step 6: Adding final touches

The part already looks very nice, but we want to have a nicer haptics and look. For this, we want to add a smoothing modifier to the part.

In short, just copy the following lines and replace the last line of the old code with these new lines:

solid part = extrusion( sketchPart, extrudeDir )
part = refacet_planes() >> smoothing( 0.4, 20 ) >> subdiv( 0.5 ) >> part

make col >> part

What we did here is putting the part in a variable (type solid) and then after extruding, applying a chain of modifiers to the part: first, subdividing the mesh for getting enough triangles to represent the smoothed surface, after that performing the actual smoothing and finally getting rid of excess triangles we do not need. (Note, that a chain of modifiers is always executed from right to left, the modifier next to the part applied first).

After hitting run code one more time, your screen should show the smooth final part, with customizable screw holes number and ready for downloading and 3D-printing!

From the Playground you can directly download your part as an STL, either by clicking the big Download button at the bottom of the parameter customizing container or, in case you minimized that container, by clicking the download symbol.

When it comes to printing material, I used 1.75 mm PLA filament, Galaxy Black Prusament and printed with the standard settings on Prusa Core One, 0.2 mm layer height and heated print bed. For me, it was fine and I really like how it came out of the printer. Depending on the purpose you plan to use your own parts for, PLA might be a bit brittle so looking for a more robust material might be a good idea.

Since the fit for the screw holes is rather important, I added a small security add-on to the diameter (already in the code provided) for making sure the screws fit through, but in case you feel that for your part and application a more tight or loose fit is better, best is to experiment and only print one test part before starting your own batch production.

In this tutorial you learned the basics of designing your own additional parts for a toy construction set using trCAD. Of course, your construction set and parts may look completely different, but I hope I could give some inspiration to make your own!

If you were new to using code for 3D designing, I hope you had fun following along. The key to master code for CAD is to have a very clear idea in mind what you want to do and make your drawings to refer to. This may be just a hand drawing or using power-point (like I did) or using a traditional CAD software.

Why does using code for CAD make sense? If you ask me, it is because in code, you can very precisely control what should happen under which condition when. You can make iterations with loops very efficiently and you can use functions and packages for encapsulating and re-using parts of your construction. Together with using open parameters, you can easily control what a user can and cannot change and make sure that a valid output is generated every time, keeping complexity away from the end user.

All of that together allows for developing design automation applications that enable mass customization of 3D printed parts that are accessible to everyone, no modelling or CAD knowledge needed. The customizer you did in this tutorial is so easy to use by just entering the number of holes, even a child could use it!

If you are interested to learn more you can find a lot of example customizers on the trCAD Playground landing page: https://trcad.trinckle.com/playground. There the trCAD manual is linked as well: https://docs.trcad.trinckle.com/trcad_manual/

I would love to see what additional parts you are coming up with.

Happy coding and making! 👩‍💻❤

In case you stumbled somewhere following along the coding steps, here you find the full code of the example:

function CurveStadium( float straightLen, float width )
{
  float radiusStadium = 0.5 * width
  curve curveStadium = <[0.0, 0.0]> -> 
                       <[straightLen, 0.0]> ->
                       arc_to( <[straightLen, width]>, radiusStadium ) ->
                       <[0.0, width]> ->
                       arc_to( <[0.0, 0.0]>, radiusStadium) -><-
                   
  return curveStadium
}

float widthPart = 22.4
float thickPart = 4.0

float diaHoles = 9.8
float distHolesBorder = 22.0

open int nHoles
{
  name = "Hole number"
  descr = "The number of holes of a construction bar."
  value = 3
  min = 2
  max = 10
}

float distHolesCenter = distHolesBorder + diaHoles
float straightLenPart = ( nHoles - 1 ) * distHolesCenter 

curve outline = CurveStadium( straightLenPart, widthPart )

vector extrudeDir = <[0, 0, thickPart]>

color col = rgb(255,255, 92)

diaHoles = diaHoles + 0.2 // make slightly bigger to ensure fitting of screw

vector centerScrewHole = <[0.0, widthPart * 0.5]>
curve screwHole = <[diaHoles * 0.5, widthPart * 0.5]> -> arc( centerScrewHole, 2PI )

float fullLenSmallHoles = 10.4
float widthSmallHole = 4.1

float straightLenSmallHoles = fullLenSmallHoles - widthSmallHole

curve smallHole = CurveStadium( straightLenSmallHoles, widthSmallHole )
smallHole = translation( 0.5 * <[ distHolesCenter - straightLenSmallHoles,
                                  widthPart - widthSmallHole ]> ) >> smallHole
                   

sketch sketchPart = outline
for( int n = 0; n < nHoles; ++n )
{
  atrafo shift = translation( <[n * distHolesCenter, 0.0]>)
  sketchPart = sketchPart - shift >> screwHole
  if( n + 1 < nHoles )
    sketchPart = sketchPart - shift >> smallHole
}

solid part = extrusion( sketchPart, extrudeDir )
part = refacet_planes() >> smoothing( 0.4, 20 ) >> subdiv( 0.5 ) >> part

make col >> part