LEGO Technic Diwheel

[thomasbrus]

Just a small little project, not much to say here 😄 Apparently this is called a diwheel or dicycle. The wheels are made using the gear rack pieces from the Liebherr Crane set. It is driven by two motors connected to the gears inside the the gear rack pieces, so it works like a planetary gear kind of. This also means the chassis is rocking back and forth when you drive so you have to take this into account when accelerating.

There is a freewheel mechanism in the middle that allows the wheels to turn forward even when the motor stops. In second video you can hear the ticking sound if you listen closely.

diwheel1.mov

diwheel2.mov

# pybricksdev run ble vehicle.py
from pybricks.parameters import Port, Button, Direction
from pybricks.pupdevices import Motor
from pybricks.iodevices import XboxController
from pybricks.tools import wait
from pybricks.robotics import DriveBase
from pid_controller import PIDController
from umath import log, copysign

left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
right_motor = Motor(Port.D)


class Controller:
    def __init__(self):
        self.controller = XboxController()

    def speed_percentage(self):
        backward_speed, forward_speed = self.controller.triggers()
        return forward_speed - backward_speed

    def turn_rate_percentage(self):
        value = -self.controller.joystick_left()[0]
        return 0 if abs(value) < 5 else value

    def exit_button_pressed(self):
        return Button.B in self.controller.buttons.pressed()


class DummyController:
    def speed_percentage(self):
        return 100

    def turn_rate_percentage(self):
        return 0

    def exit_button_pressed(self):
        return False


controller = Controller()

# Make it so that percentage_to_speed(100) returns the maximum drive and turn speed
drive_base = DriveBase(left_motor, right_motor, wheel_diameter=100, axle_track=100)

dt = 10
pid_control = PIDController(0.01, 0.0, 0.0001, dt)
pid_speed_percentage = 0


def clamp(n, smallest, largest):
    return max(smallest, min(n, largest))


def percentage_to_speed(percentage, max_speed=1000):
    return percentage / 100 * max_speed


while not controller.exit_button_pressed():
    target_speed_percentage = controller.speed_percentage()

    turn_rate_percentage = controller.turn_rate_percentage()
    turn_rate_percentage = (1 - log(clamp(100 - abs(turn_rate_percentage), 1, 100)) / log(100)) * copysign(100, turn_rate_percentage)

    output = pid_control.update(target_speed_percentage, pid_speed_percentage)
    pid_speed_percentage = clamp(pid_speed_percentage + output, -100, 100)

    drive_base.drive(percentage_to_speed(pid_speed_percentage), percentage_to_speed(turn_rate_percentage))

    wait(dt)

[laurensvalk]

Love it. Thanks for sharing!

[thomasbrus]

Rotations as in backflips/frontflips? For sure, that should be doable. Hadn't thought of that, I was going in the opposite direction and trying to stabilize it using a PID controller and by measuring the pitch value. But couldn't quite get that to work so called it a day 😄

[laurensvalk]

If you are curious, you could try installing the nightly build: https://pybricks.com/learn/getting-started/install-pybricks/#trying-the-nightly-version-optional It should have a much more stable pitch value now that we fuse acceleration and gyro data.

[thomasbrus]

Nice, will check it out!

[thomasbrus]

I installed the nightly build 👍

I think the balancing program was just too complicated. And one of the issues was that when the vehicle is in the still position it can be anywhere between 0 and -12 degrees, the center of gravity is not exactly in the middle. So if it was slightly tilted it would start driving to correct even though it was already "balanced". So I made the program a lot simpler by simply tracking the angular velocity and using that to adjust the speed and that works surprisingly well!

balancing-diwheel2-720p.mov

balancing-diwheel3-720p.mov

balancer_pid = PIDController(0.5, 0.0, 0.005, dt)

while not controller.exit_button_pressed():
    target_speed_percentage = controller.speed_percentage()

    balancer_output = balancer_pid.update(0, hub.imu.angular_velocity(Axis.Y))
    pid_speed_percentage = target_speed_percentage - percentage_to_speed(balancer_output)
    pid_speed_percentage = clamp(pid_speed_percentage, 0, 100)

    drive_base.drive(percentage_to_speed(pid_speed_percentage), percentage_to_speed(turn_rate_percentage))

    wait(dt)

[laurensvalk]

Very nice!!