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:

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

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

After that, we are left with:

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:

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

Support beam:

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:

Basic connection to build any linkage:

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

Building up:

Twisting:

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.

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.