NXT in-line skater

I found a video that features a skating robot, it moves, but skating? I did a lot of skating myself, so I started to think about a better skating movement.

It occurred to me that while skating around pylons, you don’t need to take your skates of the ground. What you do instead is hard to explain.

I tried to explain my idea to anyone who’d listen in #mindboards, but to no avail. You just have to see it with your own eyes.

It is a really fun thing to build and play around with. I suspect you can find more efficient and inexplicable ways to move and turn.

Get the building instructions for this model

This is the Mirah code I used in the video:

import lejos.nxt.Motor
import lejos.nxt.Button

def align()
	Motor.A.rotate(360 - (Motor.A.getTachoCount() % 360))
	Motor.C.rotate(360 - (Motor.C.getTachoCount() % 360))
end

speed = 150
Motor.A.setSpeed(speed)
Motor.C.setSpeed(speed)

Motor.A.forward()
Motor.C.forward()

Thread.sleep(20000)

Motor.A.stop()
Motor.C.stop()

align()

Motor.A.backward()
Motor.C.forward()

Thread.sleep(20000)

align()

Motor.A.forward()
Motor.C.forward()

Button.waitForAnyPress()

Pneumatic Bug

So there you are. This is the result of a day or two of LEGO building, followed by weeks of thinking, sawing and soldering. Lucky for you, you don’t have to go through all that, and can just buy the needed parts.

This cute little bug can walk forwards, backwards and turn around, using 4 pumps on 3 switches. The outer 4 legs can move back and forth, with left and right having an individual pump. The middle legs are connected, and can move up and down.

By tilting the middle leg right, the outer right legs come of the ground, while the middle leg on the left is off the ground, then the outer legs can be repositioned for the next cycle.

There are touch sensors on the middle legs, to detect when they are of the ground.

To build this adorable model, you need your NXT, 4 pneumatic pumps, 1 compressor pump, 3 servo valves and a servo controller.

This is the walking routine in NBC for my custom controller. The concept is the same for the Mindsensors one.

#define tilt 0
#define left 1
#define right 2
#define servoport IN_2

thread main
SetSensorLowspeed(servoport)
OnFwd(OUT_A, 100)

loop:
servo(servoport, left, 150, result)
servo(servoport, right, 150, result)
servo(servoport, tilt, 100, result)
wait 7000

servo(servoport, tilt, 150, result)
servo(servoport, left, 100, result)
servo(servoport, right, 200, result)

wait 5000

servo(servoport, left, 150, result)
servo(servoport, right, 150, result)
servo(servoport, tilt, 200, result)
wait 7000

servo(servoport, tilt, 150, result)
servo(servoport, left, 200, result)
servo(servoport, right, 100, result)
wait 5000

jmp loop

endt

NXT model of Twente One Solar Racer

I wrote earlier about the solar panels I bought from eBay, and how I connected them to the NXT. The next logical step was of course to build a robot, so why not start out with a solar racer?

I’m Dutch, so I started to look at the cars of the 2 Dutch competitors for the World Solar Challenge, the universities of Twente and Delft. Delft has won for several years in a row, but I still decided to go for the Twente car from 2007, called the Twente One.

I had several reasons for choosing the Twente one. Emotional ones, like a team member that gave a presentation about the car at my old school. Technical ones, like that the powered wheel is not also the steering one. But maybe the most interesting reason is that they have a tilting solar panel, for which they won the innovation price in 2007.

With my LEGO model of the Twente One, I tried to add all the same features as the original model, including:

  • Direct drive on the rear wheel, although the NXT motors are in fact geared down
  • Double wishbone suspension on the front wheels
  • Trailing beam suspension on the rear wheel
  • Tilting solar panels

Winter probably isn’t the best time to try to build a solar racer, but I still made a video of it driving around.

Besides of course the solar panels, this model also requires these motorcycle wheels and 4 springs of the strong variety. I had to buy these myself as well, totally worth it IMO.

I did not include building instructions for the solar panel, as they are easy to make and yours might be different. You could also just use a piece of cardboard instead(but that would be cheating). The panel connects to 3 pivot points at the top of the car.

Chocolate dispenser

The latest in chocolate breaking technology! Using patented breaker technology, bar after bar is transported and broken off. No animals where harmed in the making of this robot.

My father eats a lot of chocolate, so the original idea for this robot was for it to keep track of and limit your chocolate eating. Unfortunately the NXT doesn’t keep track of the time, so you could just restart the program and eat more.

A solution to this problem would be to use the Mindsensors realtime clock, which costs $20, but since I have no intention to actually keep this robot around, I just used it as a dispenser for the weak and lazy.

Chocolate is fed into the back of the robot and is then transported to the front. A light sensor detects the foil and aligns the chocolate to the front edge. I keep the foil around the bar to make detection easy and to keep my LEGO clean.

When the button is pushed, one bar is extended over the edge and broken off by 2 NXT motors. Check the NBC code:

#define BLOCKWIDTH 100

dseg segment
  button byte
  light word
dseg ends

thread main
  SetSensorColorFull(IN_1)
  wait 100

  OnRev(OUT_A, 50)
NotThereYet:
  ReadSensor(IN_1,light)
  brcmp EQ, NotThereYet, light, INPUT_BLACKCOLOR

  Off(OUT_A)
  RotateMotor(OUT_A, 50, -100)

StandBy:
  GetButtonState(BTNCENTER, button)
  brtst EQ StandBy button

  RotateMotor(OUT_A, 50, -##BLOCKWIDTH)

  OnFwd(OUT_BC, 100)
  wait 1000
  OnRev(OUT_BC, 50)
  wait 1000
  Off(OUT_BC)

  jmp StandBy
endt

It took some time to calibrate the machine, but it was delicious. No extra parts are required for this robot, except some chocolate.

Tower Crane

Picking up and carrying around stuff is fun, but another claw/gripper? Can’t we do something new?

That is what I did. I sat down with the idea of Pythagorean triangles in my mind, and then I imagined a tower crane, with all these diagonal truss beams. Djing!

So I started laying out triangles and piecing them together. I’m pretty content with the result, which uses 3 different triangles.

A few caveats:

  • You need a turntable, I didn’t dare putting so much stress on a single axle.
  • The hook and winch are not in the manual, I used 3 different ones, and I bet you need another 3 for your own projects.

At first I used my gamepad code to control the crane, but later I programmed it as well.

Tower cranes are usually used to build high buildings right? It’s maybe not as cool as flying robot builders, but I managed to let my crane build a tower.

The logic goes something like “turn around until the ultrasonic sensor reads less than 20cm, pull the winch down and up, go to starting position, go down and up, repeat”, and can easily be programmed in NXT-G or NBC.

Before you buy, remember that you need a turntable and of course a bit of string. Both the old and new model turntables should work with minimal modifications.

Plotter

When I got the Ultimate Builders set, it came with instructions for a plotter. Mind you, the RCX had no integrated rotation sensors, so it used a lever rotating against a touch sensor. It even used a complicated construction to drive a pneumatic pump with one motor.

It came with a program to write “LEGO”, which I did not understand, because it was huge. And it didn’t work either, but that turned out to be because of a broken sensor… after I took the plotter apart.

I just found the video of a “Lego Master builder” introducing the model.

Anyway, a plotter was on of the things on my list that had to happen properly someday. The one you see here is my third attempt. The first two where too fast, too bulky, and had a very feeble arm holding the pen.

I actually made this model before the NXTbike, but I messed up the building instructions, so I had to do it again. I can’t recommend Lego Digital Designer for any serious Technic building, use LDraw instead.

The first thing I did, even before my first attempt, was writing a virtual plotter, so I could quickly code up the alphabet. I wrote the software in Python, so that I could use the Turtle module for the virtual printer, and nxt-python for the real job. The software can be found on Github.

I made this model before I realized I should minimize the use of non-NXT parts. Ironically, this model uses a few parts from the Ultimate Builder set, but easy workarounds exist for most parts. Check the parts list before you buy.

NXTbike

I designed this robot to experiment with so-called “single track vehicle dynamics”, or in other words, balancing on a bike.

The challenge with designing a motorcycle like this is keeping he wheelbase short, and positioning the steering motor in a sturdy way.

The program for this robot is based on the principle of “steer into fall”, which means that if the bike leans over to the right, it needs to steer right to correct that.

A problem that I have with this robot is detecting the angle of the robot. The ultrasonic sensor is not precise enough and my floor not uniform enough to use the light sensor, like the NXTway does.

If you have a very uniform floor, you could use my code, but it is probably best to get a HiTechnic gyro with the software from this guy:

If you want to build this model, you need some extra wheels, check the parts list.

Automatic Gearbox

A while back I was making some large LEGO vehicle of sorts, and I was faced with the choice of gearing down my motor or dedicating a whole extra motor to controlling a gearbox.

I chose to do neither, and build an automatic one. The ones I found where to big and relied on friction and differentials. After a few email exchanges and iterations, I arrived at this compact 2-gear automatic gearbox.

The gear has 2 sides, one with a 1:1 ratio, the other with a 12:20 slowdown.

When no torque is applied, the front lever is pressed onto the 1:1 chain by a rubber band, causing it to turn faster than the 12:20 side, and thus pushing the rear lever up.

When torque is applied, the front lever is pushed up by the force, and starts to slip, making the 12:20 chain turn faster, causing the rear lever to fall back into position.

Automatic Gearbox Building Instructions