Finished the LEGO Porsche kit!

Today is photography day … here are three pictures (all depth of field effects achieved in camera, not photoshop).

Skip to content
# Category: Fun

## Photos: Lego Technic Porsche GT3

## LEGO Porsche GT3 build

## Lego Build: Porsche GT3

## 3Blue1Brown

## Nov 5 update on Christmas Light Project

## SOFTWARE

### INSTALLATION

## Geeking out even more with Pythagoras and Lego triangles

### 60 degree 3-7-8 / 5-7-8 math

### Other Fractional Construction Techniques

### Recap: Complete Pythagorean Triangle List

## Lego Technic Triangle Geometry

### Trapezoid Extension – Pythagorean

### System Brick Triangles

### General Triangles

### Non-pythagorean Trapezoids

### Approximate “standard” angles

#### 30 degrees (approximate)

#### 45 degrees (approximate)

#### 60 degrees

#### 41.4096 degrees

#### 53.130 degrees

#### Half Unit Construction

## Trebuchet works!

## Field trip to the airport fire and rescue department

## Arduino embedded-programming project

I can't complain but sometimes I still do

Finished the LEGO Porsche kit!

Today is photography day … here are three pictures (all depth of field effects achieved in camera, not photoshop).

Finally getting around to building this Porsche GT3 lego kit I received as a gift. It’s insane!

More posts later, but for now I just want to post these two pictures:

1) Modeled pistons inside an engine

2) Covered up in the final assembly

So, “you know it’s there, even if you can’t see it”. **That **is some serious attention to detail!

Later I’ll be gushing about the fact this thing has an actual, functioning, transmission in it.

Best explanations of math concepts anywhere, ever. Now with **plushies**!

Up until today I prototyped my circuit on a breadboard; today I moved it to a perf board and soldered everything up. It still works!

Here’s a shot of the perf board:

It’s just a reimplementation of the same circuit I had already breadboarded (and described in the prior post) except that I did go ahead and update **Rg** to 330Ω:

The eight infrared emitters will be remotely located out by each light strand I’m controlling. The long wires between those remote IR emitters and this board will be hooked up to the terminals as shown, generally with two wires connecting to all but the outer terminals. This is because each LED has two wires but one of them needs to be connected to the next LED in the series arrangement.

The GND goes to the Arduino ground as well as the ground of the external 12.6V power supply. The plus side of that power supply connects at the lower left and the signal from Arduino pin 3 which goes (via resistor Rg) to the MOSFET gate terminal connects at “G”.

The screw terminals I’m using come in two-terminal chunks but they can also snap together to form larger banks. They are very handy to have for projects like this.

Since this whole thing fit on one half of the perf board I can implement the second copy of this circuit on the other half in the same way.

I connected everything up and was happy to learn that my amateur soldering prowess didn’t screw anything up (and especially didn’t fry the MOSFET during soldering).

From a previous project I had some code implementing a simple JSON POST interface on an Arduino (with ethernet shield) allowing remote access to digital I/O. That code is up on github.

I took that code and modified it to accept POST requests of JSON to control sending IR codes using the IRRemote library.

The JSON it accepts looks like this:

{ "codes": [ ircode-dictionaries ], "repeat": n }

An ircode-dictionary looks like:

{ "code": 16718565, "bits": 32, "protocol": "NEC" }

The thing I’m controlling takes 32-bit IR codes via the NEC protocol; as I wrote earlier I determined this using the IRRemote library and an IR receiver/decoder in the usual way. The above code will make the LED string RED for example.

You can optionally add a “delay” element to an ircode-dictionary; it specifies a delay, in microseconds, to wait after sending the code. Although the NEC protocol allows for fairly tightly-repeated IR codes, the box I’m controlling doesn’t respond reliably unless you have about 150000usec (150 milliseconds) of delay between two consecutive IR commands. I haven’t tried to refine this number; I just know that 150 milliseconds works and 50 milliseconds doesn’t, so the true limit is presumably somewhere in between. I made the server supply a 150 millisecond delay by default unless you override that with the “delay” parameter.

You can specify multiple ircode-dictionaries in one POST; the main limitation is that there isn’t much ram (a whopping 2K!) on an Arduino so the maximum POST size my code can accept isn’t much. At the moment I have it defined as 350 characters. Still, that’s enough to allow you to do some interesting things. Only the first ircode-dictionary has to have the protocol and the bits specified; those values become the default for subsequent ircode-dictionaries in the same POST. Similarly for delay, if it’s been specified.

Given all that, we can make the LEDs rotate through RED GREEN and BLUE like this:

{ "codes" : [ { "code": 16718565, "protocol": "NEC", "bits": 32 }, { "code": 16751205 }, { "code": 16753245 } ], "repeat": 10 }

You have to be careful with the “repeat” because the Arduino server is non-responsive during the execution of all this. It’s probably best to set a “repeat” value that limits the cycle to 5-10 seconds at most (if you use the “repeat” at all even) and then use looping in your script or program driving the Arduino instead.

I wrote a python script using the Requests library to send POST requests to my Arduino. The Requests library makes it dead-simple to do stuff like this; here’s the key portions of my python code for driving my Arduino (beware of / apologies for wordpress messing up indentation and line breaks):

def sendcodes(url, code_dicts, repn=1): topdict = {"codes": code_dicts} if repn > 1: topdict["repeat"] = repn js = json.dumps(topdict, separators=(',', ':')) result = requests.post(url, data=js) return result # send NEC codes. Each argument should either be # a simple code or a tuple: (code, delay) def sendNEC(url, *codes, repn=1): a = [] for x in codes: try: a.append({'code': x[0], 'delay': x[1]}) except TypeError: a.append({'code': x}) return sendcodes(url, [{'protocol': 'NEC', 'bits': 32, **a[0]}] + a[1:], repn=repn)

I squeezed out extra spaces using the “separators” argument in the JSON conversion, just because of space limitations on the Arduino and thus not wanting to waste any of the limitation on unnecessary white space. For the same reason I only send the “repeat” element if the repeat is more than just one.

Here are some simple examples showing the LED colors changing under control of all this magic.

For the last one (“seizure”) I backed away far enough so the R/G/B LEDs could blend as they will when seen up on my house. The result looks a little bluish but I think that’s an artifact of the video. In any case I think my neighbors will enjoy that one.

While I’ve been working on electronics and software, we’ve also been installing the lights on the house. Don’t worry, I won’t actually light them up until after Thanksgiving, respecting proper tradition — but this year I need to prototype and check things out early.

Here’s a picture of some the LEDs running around one part of my roof line:

The LED strand is attached to the roof simply by magnets, as the fascia is metal and magnetic. This is going to make it easy to put up and take down each year, though storing it requires some finesse to prevent it from become a magnetic mess. Each magnet has a zip-tie attachment stuck onto it and then is zip-tied to the LED strand. At night this seems pretty bright, I’m looking forward to getting the whole project up and running soon!

In case my previous musings on lego triangles weren’t geeky enough for you, here’s some more.

In my prior note I pointed out that you could construct an exact 60 degree angle with a 3-7-8 or 5-7-8 construction, such as this one:

The blue technic beam is the “7” unit leg. Building this within an 8-8-8 equilateral triangle helps convince us that the angle opposite the 7 unit beam is a 60 degree angle.

In the prior post I wrote *“This construction is probably demonstrating some deep mathematical relationship between the 3-7-8 60 degree construction and the 5-7-8 construction; perhaps someone will point it out to me and I’ll add it back into this note.”*

Well I’ve worked it out for myself.

Review: Trigonometry says that if we know sides a, b, and c and we want to know the angle B opposite side b, we can start with the law of cosines:

b^2 = a^2 + c^2 – 2*a*c * cos B

In the case where angle B is 60 degrees, cosine(60) is exactly 1/2, so this formula becomes:

b^2 = a^2 + c^2 – a*c

Now we can see why (a,b,c) = (3,7,8) forms a 60 degree angle opposite the 7 side:

7^2 = 3^2 + 8^2 – (3*8)

49 = 9 + 64 – 24

The numbers work; (3,7,8) is consistent with that equation and therefore the angle opposite the b side is a 60 degree angle.

It follows from this that if (a, b, c) is a solution then (c – a, b, c) is also a solution. To see this, work the substitution of * c-a *for

Thus once we know (3,7,8) has the 60 degree angle in it we could find (x, 7, 8) where:

x = c – a

x = 8 – 3

which gets us the (5, 7, 8) solution.

Some other integer solution pairs to this are:

- (5, 19, 21) and (16, 19, 21)
- (7, 13, 15) and (8, 13, 15)
- (11, 31, 35) and (24, 31, 35)

That last pair is huge but might be useful if divided in two using half-unit construction.

I built a nice looking 5,7,8 connection inside a 9-9-9 equilataral, all built using system bricks just as a demo.

I had to use “pylons” (visible in the bottom view) to make this work because, as usually happens with the system brick triangle constructions, the adjacent studs will interfere unless you build up using a pylon/riser construction.

Lego CAD tools that make use of the LDraw system define brick geometry in units called LDU (an “LDraw Unit” I suppose). A standard system brick is 24 LDU high and the stud-to-stud (or hole-to-hole in technic) spacing is 20LDU. So far we have been talking about constructions using an integer number of holes (20LDU) or half-holes (10LDU).

Because of the 24:20 (6:5) ratio of stud-spacing vs brick height, turning bricks on their side gives offsets other than just integers and halves. Bricks on their sides is called SNOT: “Studs Not On Top” http://www.brickwiki.info/wiki/SNOT_techniques

This allows resolution down to 4LDU for offsets, corresponding to 0.2 of the stud-to-stud distance. By using system bricks (with technic holes as required) we open up many more angle possibilities, including some new Pythagorean triples such as:

(6.6, 11.2, 13)

Of course, that triple was already “available” as an integer construction, with the original Pythagorean triple being an enormous (33,56,65). It could be reduced to (16.5, 28, 32.5) using half-unit construction, but the SNOT techniques allow us to realize that particular construction this way:

It may be easier to see this in an LDraw:

I left the pins out of this rendering just for clarity so you could see all the holes.

Look at the vertical element in more detail:

This shows the general technique for achieving fractional distance at 0.2 resolutions. Every “system” brick laid on its side adds 24 LDU (or 1.2 “holes”) to the distance. As with the technic beams you have to be mindful of the +1 factor because what matters is the center-to-center distance. So it takes a stack of four system bricks on their side to add a total of three times the height of a single system brick. The net of this construction is that the vertical segment is 6.6 units in length. The math for the other part of the construction works similarly.

Taking all these techniques together, here is the complete list of Pythagorean Triangles you can make with the maximum dimension being less than 25 (there are more above that point), and the angle you get for the hypotenuse. The table is sorted by angle A, the smaller angle of the two non-right angles (the other angle is always 90 – A).

Table without using any SNOT techniques:

4.5 20 20.5 12.680 7 24 25 16.260 6 17.5 18.5 18.925 5 12 13 22.620 8 15 17 28.072 3 4 5 36.870 10 10.5 14.5 43.603

Table including SNOT triangles:

2.6 16.8 17 8.797 4.5 20 20.5 12.680 3.2 12.6 13 14.250 7 24 25 16.260 ... SNOT version: 2.8, 9.6, 10 6 17.5 18.5 18.925 8.8 23.4 25 20.610 5 12 13 22.620 7.2 15.4 17 25.058 8 15 17 28.072 6.6 11.2 13 30.510 3 4 5 36.870 10 10.5 14.5 43.603

Of course you can scale entries in the table. So, for example. you could make the SNOT version of (7,24,25) at (5.6, 19.2, 20) though at that point you probably might as well make it using the integer (7,24,25) construction.

Time for some fun with Pythagoras!

Lego tends towards rectangular constructs, but sometimes we might want to make triangular connections. Technic beams especially lend themselves to this.

Right-angled pythagorean triangles are fairly easy to construct. Here’s a 3,4,5 triangle:

Notice that when you build it you build it as 4,5,6. That’s because it’s the *distance* between the pin centers that has to be in the 3-4-5 ratio. Two pins separated by 2 holes are a total distance (center-to-center) of three holes apart. Or said another way, two pins right next to each other are distance “one unit” apart, not two. Thus: A two-hole beam would be a distance of “one unit” in this analysis.

There are many pythagorean integer triangles. Here’s the complete list up to a reasonable size:

- 3-4-5 (also 6-8-10, 9-12-15, 12-16-20 etc)
- 5-12-13
- 7-24-25
- 8-15-17

If you try to build these don’t forget the +1 factor for counting holes.

If we allow half unit offsets there are some more pythagorean triangles available. Obviously any of the above constructs can be divided in two; beyond those we also have:

- 4.5-20-20.5
- 6-17.5-18.5
- 7.5-18-19.5
- 10-10.5-14.5
- 12-22.5-25.5
- 13.5-18-22.5

In the 3-4-5 family the angle opposite the “4” side is 53.13 degrees. The reason this is good to know is that the standard bent beams are at that same angle (53.130) and now you know why:

If you build this you will see that the angles match up perfectly.

If you combine a pythagorean triangle with its mirror you will get an isosceles triangle. Here, for example, is a 6-5-5 construction which is two mirrored 3-4-5 triangles

Notice, once again, you build 6-5-5 as 7-6-6 if you are counting the total number of holes in each side. This kind of construction will be very strong and also has the advantage of being able to attach things to the vertical riser in the spine of the triangle and have them be “on grid” whereas the holes in the angled beams are rarely ever “on grid” except at the vertices.

Once you can make a triangle, you can make a corresponding trapezoid by extending it evenly in one dimension. This is easy to do for right (pythagorean) triangles:

Here I took a 3-4-5 triangle and extended out the base (by 4 in this case; “n” as shown in the diagram). I have to extend the connection point up top out the same amount. The geometry still works and everything lines up.

We’ll revisit this topic for non-pythagorean triangles in a moment; there are some triangles that you can extend into trapezoids and some that you can’t (easily).

You can make triangles using system (“standard lego”) bricks too:

Note how I used two 1×1 bricks to create “pylons” for the angled brick. You have to do this, or something similar, because the neighboring studs will interfere with the angled piece.

Any three beams that satisfy the triangle inequality can be formed into a triangle. In general you will need to use four beams in the construction because you need to “jump” up/down one level to make the last connection work. Look at the construction of the 3-4-5 pythagorean triangle to see an example of why 4 beams are needed (and in that case since one of the joints is a 90 degree angle I used a T piece but in general you will want to use just straight beams when making angles that are not 90 degrees).

The lengths of the triangle sides will determine the angles according to standard triangle side-side-side (SSS) solutions. Just hook them together and let the angles fall where they may.

Of course, we might like to know what those angles actually are. I wrote a small python program that calculates Lego triangle angle information for a given configuration of sides. The source is available here: http://neilwebber.com/files/legotriangles

If you prefer, here is the table of output it generates for full-unit constructions and half-units:

- Full units only: http://neilwebber.com/files/lego-t1
- Including half units: http://neilwebber.com/files/lego-t2

You can use the command line options (read the source) or just peruse the uploaded table and see that there are some other useful angles you can construct, though in some cases you will have to settle for close approximations. For example, there is no 45 degree construction but there are two that come close:

- 5-12-15 will generate an angle of 45.036 degrees.
- 13-17-17 generates 44.959

Any equilateral construction generates 60 degrees but so do these:

- 3-7-8
- 5-7-8

Here’s a 3-7-8 construction. The angle between the blue and red beams is 60 degrees.

This construction also more clearly illustrates the need to use four beams (not just three) to make a triangle because of how the “levels” at the vertices work out. One of the sides has to jump back down in order to join with the remaining side.

Because of that 60 degree angle, that implies you can build a 3-7-8 connection across an 8-8-8 equilateral triangle:

The angles opposite the blue beam (both above it and below it) are both 60 degree angles (by definition because the outer frame is an equilateral triangle). This construction is probably demonstrating some deep mathematical relationship between the 3-7-8 60 degree construction and the 5-7-8 construction; perhaps someone will point it out to me and I’ll add it back into this note.

If you have a larger equilateral triangle you can still make this connection at this point near the vertices or of course you could scale up the 3-7-8 or 5-7-8 as appropriate (possibly using half unit constructions too if necessary).

Don’t forget (in case you are confused again): building something with a 3-7-8 relationship takes hole counts of 4-8-9. You can count the holes in the above picture and verify this.

Let’s look at a 4-8-10 triangle (which would be equivalent to a 2-4-5 triangle but this is easier to construct):

As always: built as 5-9-11.

The angles on this triangle are 22.332 (between blue and yellow), 49.458 (between blue and red), and 108.21 (between red and yellow).

Let’s say we want to make a trapezoid out of this. We can, for example, extend the blue beam to the right by making it longer, and finish out the rest of the trapezoid with right angles:

but, as you can see, we have a problem with the final joint at the red/yellow (and pink) vertex. That point isn’t on grid, whereas the pink beam, the black “riser” L piece, as well as the blue base are all on grid.

We can calculate the location of the red/yellow vertex using standard trigonmetry. Using the yellow/blue vertex as the origin, the X and Y coordinates (X along the blue beam) of the end of the yellow beam will be:

X = 8 * cos(22.332°) = 7.4

Y = 8 * sin(22.332°) = 3.04

*NOTE: It’s “8” because that’s the length of the yellow side of the triangle.*

The vertex doesn’t even line up vertically even though it looks like it might. It’s just close. It definitely doesn’t line up horizontally. We have no way to make that final connection.

Generally speaking you can’t easily extend non-pythagorean triangles into grid-legal trapezoid constructions.

A few constructions come very close; whether you want to use them in your models is up to you. They aren’t “on grid” but any given construction always has a certain amount of play in it and if they are close enough then things will appear to work. I believe the Lego corporation would refuse to accept these constructions as part of a design for a set, so in that sense they are “illegal”.

Here’s one that comes very close. Take the 3-7-8 triangle we saw before:

Taking the blue base as the X axis and the blue-red vertex as the origin, we can calculate the location of the red-yellow vertex. We already know that the angle between the red and blue is 60 degrees (you can reverify this using my tables or perform your own SSS triangle solution for 3-7-8; the angle opposite the 7 side is 60 degrees). Since the red leg is 8 units in length the location of the red-yellow vertex is:

X = 8 * cos(60°) = 4.00

Y = 8 * sin(60°) = 6.93

The X coordinate works out evenly on-grid, thanks to the cosine of 60 degrees being exactly one half. The Y coordinate is off grid but close enough that the following construction will appear to work:

In reality the pink beam is at (relative) height 6.93 on its left end and 7.00 on its right, thus there is some stress/flexing in the construction to make it work. You might reduce that stress slightly by only pinning the pink beam with one pin at the right end (vs the two shown in this build).

This just happens to work out as a case where the off-grid amount is smaller than the inherent flex in the pieces. Your mileage may vary; personally I don’t use these non-aligned constructions in my models but I present this as being one that is very close to ok. You can find others generally by doing math or by just trying things to see what works within reason.

Going back to the 4-8-10 (5-9-11) construction, there **is** a way to make a trapezoid out of it, like this:

because what I did here is just extend the base, then insert a parallel corresponding extension (the black beam), and connect them with a beam (the second red beam) that is parallel to the original side of the triangle. This preserves all the geometry and gets everything lined up in the right spot; however, in this entire construction only the blue beam is “on grid”; everything else is at non-standard locations.

This structure is quite stable and reasonably strong though I’d be cautious about putting too much weight or pressure on it from top (perhaps someone will work out the statics on this one; just going by feel it seems reasonably strong but I’m not sure exactly where the forces are going when it is put into compression that way).

I already listed two constructions that are very close to a 45 degree angle; here is a more complete list of approximations to common/useful angles.

a | b | c | ∠° | Error | Comments |
---|---|---|---|---|---|

3 | 5 | 6 | ∠A = 29.9264 |
0.0736° | should prefer 4 7 8 usually |

4 | 7 | 8 | ∠A = 29.9947 |
0.0053° | closest / smallest |

7 | 12 | 14 | ∠A = 29.9947 |
0.0053° | same angle as 4-7-8; larger |

Of course multiples of those triples works, so for example 8-14-16 is another good 30 degree approximation (doubled from 4-7-8).

Half-unit constructions can get even closer:

a | b | c | ∠° | Error | Comments |
---|---|---|---|---|---|

5.5 | 9.5 | 11 | ∠A = 29.9996 |
0.0004° | |

5.5 | 14.5 | 19 | ∠B = 29.9996 |
0.0004° | same angle as 5.5-9.5-11 which is easier to build. |

7.5 | 13 | 15 | ∠A = 29.99997 |
0.00003° | nearly “exact” for all practical purposes. |

The 7.5-13-15 triple can be looked at as half of a 15-15-15 equilateral triangle. A point 7.5 along one leg is halfway; if we then went exactly 90 degrees up to the other vertex we should have a height of:

h = 15 * sin(pi/3) *# (pi/3 = 60 degrees in radians)*

which computes out to h = 12.9904. So our actual height of 13 won’t form a true half of a true equilateral triangle; it will resolve to angles that are slightly off in all spots, but based on how close 13 is to 12.99 you can see why building the triangle at 7.5-13-15 gets so close to the 30 degrees.

If you really need an exact 30 degrees you can get it from the complementary angle on an equilateral construction or from any of the other exact 60 degree constructions (see table lower down).

There aren’t any 45 degree approximations that are as close as the 30 degree ones unless we allow half unit constructions. Here is the table of some useful ones including half-units:

a | b | c | ∠° | Error | Comments |
---|---|---|---|---|---|

3 | 19 | 21 | ∠B = 45.06135 |
0.061° | |

5 | 12 | 15 | ∠B = 45.03565 |
0.036° | best/smallest integer construction. |

6 | 12.5 | 16 | ∠B = 45.00612 |
0.006° | very good; see 8-8.5-12. |

8 | 8.5 | 12 | ∠B = 45.00612 |
0.006° | Same ∠ as 6-12.5-16 but smaller. Second best known. |

9.5 | 14 | 19 | ∠B = 45.00349 |
0.0035° | Best (but uses half-units). |

11 | 18 | 24 | ∠B = 45.05405 |
0.054° | 5-12-15 is a better integer construct. |

You can, of course, easily get 60 degrees from any equilateral triangle construction (all sides equal). You can also get it from the complementary angle on any of the above 30 degree constructions.

There are quite a few triples that lead to exact 60 degree angles. Here are a few of the simpler and more likely useful ones (including half units):

a | b | c | Comments |
---|---|---|---|

1.5 | 3.5 | 4 | |

2.5 | 3.5 | 4 | |

2.5 | 9.5 | 10.5 | |

3 | 7 | 8 | Just double 1.5-3.5-4 |

4 | 6.5 | 7.5 | |

5 | 7 | 8 | Just double 2.5-3.5-4 |

NOTE: In all of these, it is angle **B** that is the 60 degree (exact) angle.

Say what? Well, the cosine of 41.4096 is 0.75, which means that a beam on this angle will generate a half-unit offset at two holes and every four holes thereafter.

Is this useful? I’m not sure. There is a problem that the sine (0.6614) is nothing useful, so this means that while your beam will have holes at half-unit offsets in one dimension, the other dimension will never be on-grid. Nevertheless, for your amusement, I present this table:

a | b | c | cosine | Comments |
---|---|---|---|---|

2 | 2 | 3 | cos(∠A) = 0.75 exact |
Isoceles; angle B also works. |

3 | 8 | 10 | cos(∠B) = 0.75 exact |
Note this one is angle B |

4 | 5 | 6 | cos(∠A) = 0.75 exact |

Here’s an example 2-2-3 construction, with the orange lines showing which holes (in the blue beam) are on half-unit offsets from the adjacent beam. Any appearance of not being in alignment is an artifact of the 3D rendering; the math works. However, as already pointed out, the holes are definitely off-grid in the other dimension so I’m not sure how this sort of construction might be useful. I present it anyway just as food for thought.

If for some unusual reason you needed to get a very specific offset, you could use this cosine concept to figure out what angle you’d need to get you there. Let’s say you need an 0.6 offset and you’ve decided (usually for construction reasons) you want to go three units along the hypotenuse to get there. You need an angle that has a cosine of 0.2, which, after you’ve gone three units along the angled beam will have moved you 0.6 on the rectilinear grid. You find the angle using arccos; that angle would be 78.463 and you could build it using (per the table or the program) 5-6-7.

Admittedly, it’s going to be a very unusual set of circumstances that makes you want special offsets — probably involving integrating with other non-Lego parts, or desparately trying to make a non-standard trapezoidal construction work out. Regardless, you’ll still have the problem of the other dimension which just won’t be where you want it anyway. In reality you’ll probably just use an axle and one piece slid along the axle (thus taking on a non-grid position) to get there; thus all this math is probably a waste of space. But maybe it will inspire someone to do something particularly clever one day.

We already saw that this angle (more precisely it is 53.130102) appears in the 3-4-5 family of pythagorean triangles and is the angle of one of the standard lego “bent” beams.

Are there any other triples that generate this angle? Yes, there are. First of all, any isoceles triangle constructed using a mirrored pythagorean 3-4-5 (or multiples of this) will have this angle. We already saw that in the 6-5-5 example.

Other combinations (that are not 3-4-5 in disguise) that give a 53.1301 angle are:

a | b | c | Comments |
---|---|---|---|

2 | 6.5 | 7.5 | |

4 | 13 | 15 | Just double 2-6.5-7.5 |

5 | 8.5 | 10.5 | |

6.5 | 7 | 7.5 | Angle A |

There are actually quite a few of these; I’ve only listed some above. All of those except the last form the 53.130 angle at B.

There are many ways to generate half-unit offsets with technic; here’s one construction you may find handy when trying to make these triangles:

That’s probably the best one I’ve found so far. You can build this with the 1×2 bricks with pins, as shown, or the 1×2 technic bricks (with holes) and separate pins.

Here’s another technique that isn’t quite as elegant but might be handy at times:

The yellow beam and the holes the yellow connector (usually red in real life) form a beam of total length 7.5 (the two holes in the connector are at 6.5 and 7.5).

As shown above the half offset connector is held in place by an axle pin and isn’t necessarily completely stable. You can brace it in a variety of ways if necessary:

That’s it for today’s Lego rambling. Happy Building!

*The drawings in posting were created with Bricksmith and rendered using LDView all made possible via LDraw. *

I completed my trebuchet. Video here: Trebuchet

Built from this kit, it is a model of the Stirling Warwolf. As they say:

During a siege of Stirling Castle in 1304, Edward Longshanks (Edward the first, King of England) ordered his engineers to make a giant trebuchet for the English army, named “Warwolf”.

With one blow, Warwolf leveled a section of wall, successfully concluding the siege of Stirling Castle. The Stirling Warwolf is generally thought of as the most powerful and most famous of the trebuchets in history.

Now that the model works, the next step is obviously to build a full scale version!