Lego Technic Rubik’s Cube Machine

The Micropython code is easy to change to Python code using the Build Hat classes. I've used procedural programming in Micropython because it's easy to read. But I wrote a rubiksCube-class for the Raspberry Pi. It's still easy to read, because I didn't fully optimize the number of movements to solve the cube.

The class starts with an init-function. It resets all angles and places the machine in the rotate-position (see Movements and Functions):

class rubiksCube:

   def __init__(self, motorFunction, motorRotate):
      self.motorFunction = motorFunction
      self.motorRotate = motorRotate

      self.gearsFunction = 1/(5/27)           # 5.4
      self.gearsRotate = 1/((5/27) * (12/20)) # 9.0

      self.function = -1
      self.position = -1

      rubiksCube.initFunction(self)
      rubiksCube.rotatePosition(self)
      rubiksCube.initRotateClockWise(self)

There are 2 variables which contain the function and position. The functions are:

• 0: turn-position
• 1: rotate-position
• 2: flip-position

And the positions are between 0 (full clockwise) and 3 (full counterclockwise) in steps of 90 degrees.

One improvement to reduce the number of movements is to remember the start-function variable before flipping the cube. This means that the cube doesn't always return to the rotate-position between each step.

   def flipcube(self):
      oldfunction = self.function
      rubiksCube.turnPosition(self)

      degrees1 = 90 * gearsFunction
      degrees2 = 92 * gearsFunction
      motorFunction.run_for_degrees(degrees1, speed=-30, blocking=True)
      motorFunction.run_for_degrees(degrees2, speed=+30, blocking=True)

      newfunction = self.function
      if oldfunction != newfunction:
         rubiksCube.rotatePosition(self)

Flipping the cube always starts at the turn-position. The cube is moved to the flip position (a movement of -90 degrees), and back tot the turn-position (about +92 degrees). This movement makes the whole cube rotate/flip 90 degrees. The extra 2 degrees compensate for the inaccuracy of the motors.

The number of degrees required to rotate the cube is stored in a list of 16 values. The index-value is calculated using the start- and end-position. For example: Moving from 0 (full clockwise ) to 3 (full counterclockwise) gives an index value of 3 (0 x 4 + 3). The value of -3 gives a rotation of -279 degrees (-3 x 93).

   def rotateTo (self, toPosition):
      oldfunction = self.function
      rubiksCube.rotatePosition(self)

      moves = [[ 0], [-1],    [-2],    [-3], 
               [ 1], [ 0],    [-2, 1], [-2], 
               [ 2], [ 2,-1], [ 0],    [-1], 
               [ 3], [ 2],    [ 1],    [ 0]]

      fromPosition = self.position
      index = fromPosition * 4 + toPosition
      for move in moves[index]:
         degrees = move * 93 * gearsRotate
         motorRotate.run_for_degrees(degrees, speed=30, blocking=True)
      self.position = toPosition

The movements are optimized to compensate for the lack of absolute position of the motors. Moving from 90 to 180 degrees is done by +186 degrees and -93 degrees. The 186 degrees movement resets the motor-position, and the -93 degrees gives the correct position. Each movement in this function contains an angle reset (This is mainly done for non-magnetic cubes).

Each cube algorithm is defined as a function. These functions aren't optimized to reduce the number of movements. The F-function (Front) flips the cube once, turns the lower row, and flips the cube 3 times. This causes the cube to start from the same starting position each step.

#  turntype: 0 clockwise
#            1 counterclockwise
#            2 halfturn

   def F(self, turntype):
      oldfunction = self.function

      rubiksCube.flipcube(self)
      rubiksCube.turn(self, turntype)
      rubiksCube.flipcube(self)
      rubiksCube.flipcube(self)
      rubiksCube.flipcube(self)

      newfunction = self.function
      if oldfunction != newfunction:
         rubiksCube.rotatePosition(self)

The main program initializes the motors, the cube machine and places the green ‘label' at front.

motorFunction = Motor('C') # function motor
motorFunction.plimit(0.7)

motorRotate = Motor('D')   # rotate motor
motorRotate.plimit(0.7)

# init and green at front
cube=rubiksCube(motorFunction, motorRotate)
cube.rotateTo(1)

cube.runList (["R2","D","B","U2","F'","L'","B","L2","D2","R'","L2","U","F2","D","L2","U2","F2","L2","B2","U2"])

Finally, the runList-method steps through the solving algoritm. This part must be modified using the algorithm given by the Rubik's Cube Solver website.

Step 10: Python Interactive Prompt

The python3 code can be started from an interactive prompt. This is especially useful for testing and debugging the Python code.

Open “python3” from the unix prompt:

python3

Load and run the testCube.py file (or the rubiksCube.py file) which contains the cube-class. Define both motors and init the cube class.

exec(open('testCube.py').read())

motorFunction = Motor('C') # function motor
motorFunction.plimit(0.7)

motorRotate = Motor('D') # rotate motor
motorRotate.plimit(0.7)

# init and green label at front
cube=rubiksCube(motorFunction, motorRotate)
cube.rotateTo(1)

Call one of the functions to test the class. For example:

cube.runList (["D","L","R","U","B","F","F'","B'","U'","R'","L'","D'"])

cube.flipcube(flipspeed = 40, flipangle = 100)

cube.rotateTo(3)

Exit the interactive shell after testing.

exit()

Remember to reload the cube-class after changing the testCube.py-file.

Step 11: Final Words

It's relatively easy to get started with Micropython programs on the LEGO Technic Hub. Which can be done with any of the LEGO Technic Powered UP sets. All required documentation is available at Pybricks. The program size is somehow limited, but it doesn't require any additional hardware.

Using a Raspberry Pi and the Build HAT gives more possibilities. In addition to programming the LEGO motors and sensors, additional GPIO ports are available for other hardware. The ‘stop until stalled' can be replaced with microswitches. And a webcam can be used to read the initial cube's colors.

I've limited myself to parts of the Zetros Truck in this Instructable. But I definitely plan to use the color sensor in one of the next versions as well.

Source: Lego Technic Rubik's Cube Machine