Lego technic techniques

When building some technic MOC, I find that switching orientation is a part that is time consuming and very ad-hoc. Switching orientation is the equivalent of SNOT (Studs Not On Top) for technic build (I don’t know of a more official term). I usually end up randomly trying the connector du jour until getting something that works. It’s now time for a more rigorous approach.

One of the greatest books about lego technics (The Unofficial LEGO Technic Builder’s Guide) does contain a wonderful amount of information, but not much about studless orientations connections. It’s probably too evident for builder with this amount of experience.

How many orientations are there?

Before figuring out the connections, we need to figure out how many relative position we have. Let’s consider the relative position of 2 studless technic beams, we will have the beam of reference in red and the one we’d like to attach in black.

Since we are ignoring translations for now, we can enumerate this in term of rotations. In 3D we can code rotations using Euler angles. There are many choices in term of conventions, here we’re going to stick with the closest to some modeling software like stud.io. In stud.io, you can rotate around the Y axis using up/down and around the Z axis using left/right. The rotation are extrinsic: they use the scene axis, not the brick axis. With this, we chose to use Euler extrinsic rotations given as z-y-z.

Taking into account the symmetry of the beams and given that we’re only interested in perpendicular constructs, we have 8 possible rotations:

  • (0,0,0)
  • (0,0,\pi/2)
  • (0,\pi/2,0)
  • (0,\pi/2,\pi/2)
  • (\pi/2,0,0)
  • (\pi/2,0,\pi/2)
  • (\pi/2,\pi/2,0)
  • (\pi/2,\pi/2,\pi/2)

However, of these 8 rotations, we can eliminate a few of them

(0,0,0)
(0,0,\pi/2)
(0,\pi/2,0)
(0,\pi/2,\pi/2)
(\pi/2,0,0) just a rotation around z, it’s the same as (0,0,\pi/2)
(\pi/2,0,\pi/2) this is a rotation around z of pi, for beam this the same as (0,0,0)
(\pi/2,\pi/2,0)
Note the color here, this is to highlight that this is equivalent to the (0,\pi/2,\pi/2).
(\pi/2,\pi/2,\pi/2)
That’s a rotation around the X axis.

 

After that, we are left with:

  • (0,0,0)
  • (0,0,\pi/2)
  • (0,\pi/2,0)
  • (0,\pi/2,\pi/2)
  • (\pi/2,\pi/2,\pi/2)

So we have 5 possible relative orientations. Now, we can start enumerating different way to connect those. I’ve been trying to give them some names, but those are not the best…

No rotation: (0,0,0)

That’s the most basic one, and usually it’s not a problem to set up this one.

Support beam: (0,0,\pi/2)

This one is very useful to provide strength: for example to prevent several parallel beams from separating.

The next connection can be found on the Mine Loader (42049) it’s pretty useful to serve as guide for axles, but not too strong for torsion.

Linkage rotation: (0,\pi/2,0)

Basic connection to build any linkage:

If you don’t need the mobility, it’s better to use the L-shape pieces:

Building up: (0,\pi/2,\pi/2)

Twisting: (\pi/2,\pi/2,\pi/2)

Conclusion

I think that’s a good start: let’s see in practice how much it helps. I’ll definitely be adding some more combination here as I discover them around.

Lego table corner (3d printed)

I use particle boards as Lego tables: the advantage is that they can be easily cut at custom dimensions (read: integer multiple of studs, or even integer multiple of baseplates). This is particularly useful when setting up a Lego train around the room. The disadvantage is that the corners are quite sharp and painful for the head (or back). Also, the baseplates might slide on the board.

Enter the custom table corner. This is a 3D printed corner, just at the right dimensions, designed to slide into the baseplate studs: holding both the baseplate and the corner in place.

Here are a few pictures:

Corner with space for the studs

Corner holding the baseplace in place

Corner in place on the table

This shape can be generated using the following solid python code (also available on github):

import math
from solid import *
from solid.utils import *

output_file = 'corner.scad'

# size in mm
corner_height = 30. + 2
corner_size = 43.
wall = 5

table = cube([40,40, 22], center=True)

stud_height = 1.6 + 0.3
stud_diam = 4.8 + 0.3
for i in range(-2,3):
  offset = i*8. + 0.5
  dig = translate([offset, 0, 11 ])(
    cube([stud_diam, 40, stud_height * 2], center=True))
  table += dig

corner = translate([0,0,0.5])(minkowski()(
  cube([corner_size-10, corner_size-10, corner_height/2], center=True),
  cylinder(r=10, h=corner_height/2., center=True)))

size_slant = 100.
offset = size_slant/(2*math.sqrt(2.))
slant = translate([offset,offset,0])(
  rotate(a=45, v=[0,0,1])(
    cube([size_slant, size_slant, 40], center=True)))
side1 = translate([0,30,0])(
  cube([100, 20, 40], center=True))
side2 = translate([30,0,0])(
  cube([20, 100, 40], center=True))

slant += side1 + side2

c = corner - slant - table

# position the final product
final = translate([0,0,27.5])(rotate(a=90, v=[1,0,0])(c))

scad_render_to_file(final, output_file)

This generates the CAD file suitable for 3D printing. You can also find the file on thingiverse.

3D printing Lego bricks

tl;dr: no (well… mostly).

With 3D printing becoming affordable to do at home, the dream of every lego lover seems to come true. Need a 2×4 in purple? no problem, I’ll print it. Missing a 1×5? To the printer baby!

But life is not that easy.

First the cost. You need to buy the stuff you feed the printer: if you use the same plastic as Lego, that’s ABS. The ABS filament that you put in the printer cost about USD 25 to 30 per kg. As a comparison, you can buy real Lego bricks on Ebay for USD 15-20 per kg. So, if you want a lot of bricks, you can just get them second hand by bulk. Some might complain that second hand bricks might be scratched, but if you think 3D printing will be better, read on.

Then there is the quality. The Lego Group doesn’t 3D print the bricks, it uses injection molding machines. The tolerance on the bricks is about 2 micrometer. As a comparison, most home 3D printers are precise to about 0.1 mm, that’s 100 micrometer. About 50 times worse that standard Lego bricks. To give an idea of the scale, if you were scaling a 2×4 brick to get the same relative accuracy with your 3D printer, the brick would end up measuring about 1.6 meters long. That would be a lot of plastic (250 kg to be precise).

But, it might make sense in some cases: when you need a brick that doesn’t exist. For example a lego railroad crossing (available on thingiverse):

3d printed lego railroad crossing

3d printed lego railroad crossing

This, enabled hours of crazy laugh around countless train accidents. Definitely worth it.