Automatic gearbox

[thomasbrus]

YouTube Video

Thought I'd share this as well in case others may find it useful. Basically this program selects the gear based on the throttle percentage (this could be controlled via an XBOX controller for example). The lowest gear is selected that can still produce the desired output speed, so you are basically trading torque for speed.

A side effect of this gearbox is (if I'm not mistaken) that switching gears should be smoother compared to running the motor at constant speed. Since the speed of the motor is adjusted to match the output speed when shifting gears (see chart 1). If you run the motor at constant speed and switch gears, then the vehicle suddenly changes speed, which is putting stress on the gears.

chart1	chart2	chart3

# pybricksdev run ble shifter.py
from pybricks.hubs import TechnicHub
from pybricks.parameters import Port, Color
from pybricks.pupdevices import Motor
from pybricks.tools import wait


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


class Gear:
    MAX_INPUT_SPEED = 390 / 360 * 1000

    def __init__(self, ratio: float):
        self.ratio = ratio

    def calculate_input_speed(self, output_speed: int):
        return self._assert_input_speed(output_speed / self.ratio)

    def calculate_output_speed(self, input_speed: int):
        return self._assert_input_speed(input_speed) * self.ratio

    def max_output_speed(self):
        return self.MAX_INPUT_SPEED * self.ratio

    def can_handle_output_speed(self, output_speed: int):
        return abs(output_speed) <= self.max_output_speed()

    def _assert_input_speed(self, input_speed: int):
        if abs(input_speed) > self.MAX_INPUT_SPEED:
            raise ValueError(f"Input speed {input_speed} is out of bounds")

        return input_speed


class AutomaticGearbox:
    GEAR1 = Gear(8 / 24 * 8 / 24)
    GEAR2 = Gear(12 / 20 * 8 / 24)
    GEAR3 = Gear(8 / 24)
    GEAR4 = Gear(12 / 20)
    GEARS = [GEAR1, GEAR2, GEAR3, GEAR4]
    SHIFTER_ANGLES = [0, 90, 180, 270]
    LIGHTS = [Color.BLUE, Color.GREEN, Color.ORANGE, Color.RED]

    def __init__(self, shifter_port: Port, driver_port: Port):
        self.position = 0
        self.shifter_motor = Motor(shifter_port)
        self.driver_motor = Motor(driver_port)
        self.max_output_speed = self.GEARS[-1].max_output_speed()
        self.shift_to(0)

    def throttle(self, percentage: int):
        desired_output_speed = self.throttle_percentage_to_speed(percentage)

        for position, gear in enumerate(self.GEARS):
            if gear.can_handle_output_speed(desired_output_speed):
                break

        self.shift_to(position)
        self.driver_motor.run(self.current_gear().calculate_input_speed(desired_output_speed))

    def throttle_percentage_to_speed(self, percentage: int):
        return self.max_output_speed * percentage / 100

    def set_hub_light(self, hub: TechnicHub):
        hub.light.on(self.LIGHTS[self.position])

    def current_gear(self):
        return self.GEARS[self.position]

    def shift_up(self):
        self.shift_to(self.position + 1)

    def shift_down(self):
        self.shift_to(self.position - 1)

    def shift_to(self, gear: int, wait=False):
        self.position = clamp(gear, 0, len(self.GEARS) - 1)
        self.shifter_motor.run_target(speed=1000, target_angle=self.SHIFTER_ANGLES[self.position], wait=wait)


hub = TechnicHub()
gearbox = AutomaticGearbox(Port.A, Port.B)
percentage = 0

while percentage < 100:
    gearbox.throttle(percentage)
    gearbox.set_hub_light(hub)
    wait(200)
    percentage += 1

while percentage > 0:
    gearbox.throttle(percentage)
    gearbox.set_hub_light(hub)
    wait(200)
    percentage -= 1

[dlech]

Cool project! Nice to see the plots too.