Thoughts about the 42009 B model

image

As with the A model I find the boom extremely heavy compared to the rest of the model. It is very densely build with many reinforcements. And of course it should be or else it would come apart when it is extended or takes some weight. It makes one worry the linear actuators will break.
The lorry looks like it is imagined together from the collection of parts is left over after building the container grabber. But it works. It has four wheel steering and a nice locking system to secure the container. It is a shame there is no engine. The designer could easily have opted to not put a V8 in the container grabber, but instead make it a four cilinder so there would be parts left to build an engine for the lorry.
On the end of the boom there is the actual device that grabs the container and it is of beautiful design. Small arms help align the grabber to the container and four pins move in to both short sides of  the container and ‘hook’  in. This is one of the power functions. 
I enjoyed building it. But it will not be a display item.

image

Advertenties

Half way building the 42009 B model

image

42009 B model

It took me some time to ‘unbuild’ the crane model. I am using that word purposely because it takes some smarts and a lot of patience to take it apart without having to resort to the use of tools that should remain in the toolbox. I am into day two of the new build and this is what I’ve got so far. It will be a telehandler with a prop to pick up containers.  The container and a lorry to load it on are also part of the build. As with most sets the A model is by far superior. But it’s nice enough.  I like the way the cabin can be raised and lowered. Execution of this idea however is very poor.  The black gear on the front is connected to the gearing that raises and lowers the cabin via a long axle. There is too much resistance to use this without twisting and permantently disforming the axle. Maybe some more gearing down would do the trick.

image

Dismantling my mobile crane model

image

Lego Technic Mobile Crane MK II 42009

So I will be dismantling my Lego Technic Mobile Crane MK II today. I build it last year and it has been sitting on a bookshelf for week now. It’s time to take it apart and build the B model. Notice the small modification I made on top of the cabin. There actually was no proper rest for the boom in the original building instructions.  There were however some extra parts.  I fashioned them into this grey boom rest. Now it sits more stable during ‘transport’ and it’s much more clear for the operator when the boom is all the way down (and that’s easier on the gears).
Anyway, it is coming apart!

image

Lego Technic Mobile Crane MK II in four pieces

So what does the caret operator do?

In my previous two posts I was squaring in a tedious way. Something like this : self.size*self.size. There is nothing wrong with it, but how to cope when I would have to calculate x to the power of 12. My code would definetly become unreadable. Of course, coming from a BASIC background I first tried using the caret operator (‘^’).  But the caret operator is used in different languages for very different things.  I already knew that and just couldn’t be bothered looking it up and just used the definition of a square. But here it is: a**b gives a to the power b in Python. But if the ** operator is used to raise a number to a power, what does the caret do? It does do something because Python says:

>> 2^2
0
>>> 2^3
1
>>> 2^4
6

And that certainly has nothing to do with any exponent of anything..

The caret operator is a bitwise XOR operator. It only returns true (1) if exactly one of the operands is true.

(bits)  (int)

0010    2
0010    2
——    (xor)
0000    0

0010    2
0011    3
——   (xor)
0001    1

0010    2
0100    4
——    (xor)
0110    6

It actually works the same in JavaScript.

 

Pythagoras Tree [2]

I tried the object approach on my Pythagoras Tree. When a Tree object is created it initially shows nothing on the screen but a blank canvas. Each time the method grow() is called on the Tree object it grows a ‘generation’. Much like a real tree would grow a bit each year.

tree-animated

The program actually looks a lot like my earlier version. You might notice these differences:

  • Each recursive call to create a ‘tree’ gets its own turtle (1024+1 turtles for n=10)
  • I need the position of the current turtle and give them as arguments to a new Tree object I create. I use the Turtle’s xcor() and ycor() methods to retrieve the x and y coordinates and pass them to the constructor.
  • I use a helper method set_start_rightbranch() to offset the starting point to right place for the drawing of the right branch.
  • To help decide a branch if it has yet to grow I introduced the property ‘grown’ to the Tree object. At creation it is set to False and after growing the grow method sets it to True.
  • I set the turtle speed to fastest (and that’s still pretty slow)
  • I have chosen to hide the turtles (it was unsetteling to see that many turtles on the screen)

Code:

import math
import turtle

class Tree:
    def __init__(self, x, y, size, angle):
        self.grown = False
        self.x = x
        self.y = y
        self.size = size
        self.angle = angle
        self.t = turtle.Pen()
        self.t.speed(0)
        self.t.hideturtle()
        self.t.penup()
        self.t.goto(x, y)
        self.t.left(90)
        self.t.right(self.angle)
        self.t.pendown()
        
    def grow(self):
        if not self.grown:
            self.t.forward(self.size)
            self.leftbranch = Tree(self.t.xcor(), self.t.ycor(), \
                             math.sqrt((self.size*self.size)/2), self.angle-45)
            self.t.right(90)
            self.t.forward(self.size)
            self.rightbranch = Tree(self.t.xcor(), self.t.ycor(), \
                             math.sqrt((self.size*self.size)/2), self.angle+45)            
            self.t.right(90)
            self.t.forward(self.size)
            self.t.right(90)
            self.t.forward(self.size)
            self.t.right(90)
            self.grown = True
            return
        else:
            self.leftbranch.grow()
            self.rightbranch.set_start_rightbranch()
            self.rightbranch.grow()
            return

    def set_start_rightbranch(self):
        self.t.penup()
        self.t.left(90)
        self.t.forward(self.size)
        self.t.right(90)
        self.t.pendown()
        return

tree = Tree(-50, -200, 100, 0)

for i in range(0, 10):
    tree.grow()