Motors not working with high memory usage?

[yannerous]

My Issue:

I encounter a problem with my code that often crashes when I try to move the motors. This issue occurs particularly when I am using a lot of memory and my coroutine has run for some time.
It doesn't always crash at the same place, but it is always OSError: [Errno 1] EPERM when moving a Motor.
I have not found a way to replicate it with a simpler program to isolate the problem, but any advice would be appreciated!

My Question:

Is this a bug in my code or maybe even in the firmware? What should be my next steps towards debugging this?

Example Traceback:

Traceback (most recent call last):
  File "Gamemaster.py", line 83, in <module>
  File "Gamemaster.py", line 46, in Mainloop
  File "RobotControl.py", line 54, in PlayMove
  File "RobotControl.py", line 158, in _move_x
OSError: [Errno 1] EPERM: 

The requested operation is not valid in the current state:
--> Check the documentation for required conditions.
--> Check the line in your script that matches
    the line number given in the 'Traceback' above.

Memory Usage:

stack: 1300 out of 34428
GC: total: 248320, used: 141232, free: 107088
 No. of 1-blocks: 5574, 2-blocks: 381, max blk sz: 346, max free sz: 2986

For contex:

I want to use a Lego Spike Prime robot to play Connect 4.
The Program is separated into multiple classes, one for controlling the hardware, one for calculating the next moves and one for coordinating the others. The Classes work on their own and the issue only arises when combined with the coordinating class, but I cant see what would be causing it.

I have attached all files and a class diagram(not 100% accurate) if you want to take a look at the complete Project.
pybricks-backup-2025-05-19_12-47-06.zip

Below are the main parts of the program I suspect cause the issue

The coordinating class is:

import PlayerAPI
import board
import BotHash
import RobotControl

from pybricks.tools import multitask, run_task, StopWatch,wait
from pybricks.parameters import Button
_MOVETIME = const(20_000)
class Gamemaster:
    def __init__(self, Player:PlayerAPI.PlayerAPI,Bot:PlayerAPI.PlayerAPI):
        self.Player:PlayerAPI.PlayerAPI = Player
        self.Bot:PlayerAPI.PlayerAPI = Bot
        
        self.gameboard = board.board()
        self.turnNumber = 0

        self.timer = StopWatch()
        self.timer.resume()#Start Timer

    def Mainloop(self):
        print("begin")
        while not self.gameboard.is_draw():
            await multitask(self.HandleOpponentTurn(),self.Bot.runBackground())
            self.gameboard.print_board()

            move = await self.Player.GetMove()
            print(move)
            #Retry until it returns a valid move
            if not self.gameboard.play_move(move):
                print("Cant Play ", move)
                self.gameboard.print_board()
                print("Exiting")
                raise SystemExit
            
            await self.Bot.PlayMove(move)

            await multitask(self.Bot.runBackground(),self.PlayBestMove())

            move = await self.Bot.GetMove()
            if not self.gameboard.play_move(move):
                print("Cant Play ", move)
                self.gameboard.print_board()
                print("Exiting")
            
                raise SystemExit
            await multitask(self.Player.PlayMove(move),self.doNothing())

            await self.Bot.PlayMove(move)

            self.gameboard.print_board()
        pass

    async def PlayBestMove(self):
        while self.timer.time() < _MOVETIME:
            print(self.timer.time())
            await wait(100)
        await self.Bot.stopBackground()
        await wait(1)

        return True
    async def doNothing(self):
        await wait(1000)
        return
    async def HandleOpponentTurn(self):
        #Wait for Signal to start Searching
        while True:
            if Button.CENTER in self.Player.hub.buttons.pressed():
                break
            elif Button.LEFT in self.Player.hub.buttons.pressed():
                self.Bot.print_latex(self.Bot.curGameBoard(),depth=2,start=0)#print the first two levels of the gametree
                self.Bot.print_latex(self.Bot.curGameBoard(),depth=4,start=2)#print the gametree beginning at the 2 Level using the best moves for the first two
            await wait(0)
        print("Button Pressed")
        await wait(1)
        #Reset Timer to Reference my Turntime
        self.timer.reset()
        await self.Bot.stopBackground()
        return True

if(__name__=="__main__"):
    game = Gamemaster(Player=RobotControl.RobotControl(True),Bot=BotHash.BotHash(False))
    print("begin")
    run_task(game.Mainloop())
    print("End of Program")
    pass

The Class that is responsible for controlling the Robot is:

from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor, ForceSensor
from pybricks.parameters import Color, Port, Button, Stop
from pybricks.tools import wait, StopWatch, multitask, run_task

import gc
import PlayerAPI
import board

# --- Hardware Setup ---
hub = PrimeHub()
left_color_sensor = ColorSensor(port=Port.A)
force_sensor = ForceSensor(port=Port.B)
right_color_sensor = ColorSensor(port=Port.C)
piece_motor = Motor(port=Port.D)
sensor_motor = Motor(port=Port.E)
drive_motor = Motor(port=Port.F)


# --- Constants ---
COLUMN_COUNT = 7
ROW_COUNT = 6
COLUMN_STEP = 111 #deg
ROW_STEP = 95 #deg
PIECE_DROP_ANGLE = 360
DRIVE_SPEED = 900 #max. reliable speed
SENSOR_SPEED = 900 #max. reliable speed

class RobotControl(PlayerAPI.PlayerAPI):
    """Controls the robot for the game."""

    def __init__(self, is_player_one: bool, game_board:board.board = None):
        super().__init__(is_player_one)
        if game_board == None:
            game_board = board.board()
        self.robot_position = 1       # Current column position (1 = far left, Einwerfer)
        self.sensor_position = 1      # Current row position (1 = bottom)
        self.game_board = game_board  # Reference to the game board object
        self.NewPieceCol = 0
        self.hub = hub
        self.hub.system.set_stop_button((Button.LEFT,Button.RIGHT))
        print("finished Player init:")

    async def calibrate_position(self):
        """Calibrate the robot position using a force Sensor."""
        while await force_sensor.force() == 0:
            drive_motor.run(-200)
        drive_motor.stop()
        await wait(20)#short delay(may not be neccesary)
        self.robot_position = -3.15

    async def PlayMove(self, col_num: int):
        """Drops a piece into the specified column.""" 
        await self._move_x(col_num - self.robot_position)
        self.robot_position = col_num

        moved = False
        while not moved:
            try:
                await piece_motor.run_angle(350, PIECE_DROP_ANGLE)  # Drop the piece
                moved = True
            except:
                await wait(1)
                print("retry move x")
        await wait (200)
        self.game_board.play_move(col_num)
        await self.calibrate_position()
        

    async def GetMove(self):
        """Detects the opponent's move and returns the column number."""
        await self.calibrate_position()  # Kalibriere vor Scan
        for col in (1, 3, 5, 7):
            col1 = col
            col2 = col + 1 if col < 7 else None #column 7 is scanned separately

            #get highest and lowest occupied row of the 2 columns
            row_candidates = [
                1,
                await self._get_highest_occupied_row(col1),
                await self._get_highest_occupied_row(col2)
            ]
            # --- Filter None values before using max/min ---
            filtered_rows = [r for r in row_candidates if r is not None]
            end_row = max(filtered_rows) if filtered_rows else 1

            row_candidates = [
                2,
                await self._get_highest_occupied_row(col1),
                await self._get_highest_occupied_row(col2)
            ]
            # --- Filter None values before using max/min ---
            filtered_rows = [r for r in row_candidates if r is not None]
            start_row = min(filtered_rows) if filtered_rows else 2

            if col1 == 7: #column 7 is scanned separately
                start_row = end_row
                scan_rows = [start_row]
            else:
                scan_rows = [start_row, end_row]

            # Move to correct position to scan columns
            target_col = col1 - 0.5 -self.robot_position if col1 == 1 else col1 - self.robot_position
            #Scan Row with color sensor on the right
            if col1 == 7:
                target_col = target_col - 1
            await multitask(
                self._move_x(target_col),
                self._move_y(start_row - self.sensor_position)
            )
            if col1 == 7:
                self.robot_position = 6  # Robot scans column 7, but is at colum 6 physically
            else:
                self.robot_position = col1
            self.sensor_position = start_row

            for row in scan_rows:
                await self._move_y(row - self.sensor_position)
                self.sensor_position = row
                if await self._is_new_piece(col2, row):
                    col = col2
                elif await self._is_new_piece(col1, row):
                    col = col1
                else:
                    continue

                await self._return_to_start()
                self.NewPieceCol = col
                self.game_board.play_move(col)
                return col

    async def _get_highest_occupied_row(self, col):
        """Returns the highest occupied row in a column."""
        if col is None:
            return None
        tempboard = self.game_board.getBoardList()
        for row in range(1, ROW_COUNT + 1):
            if tempboard[ROW_COUNT - row][col - 1] == 2:
                return row
        return 1  # Default if nothing found

    async def _is_new_piece(self, col, row):
        """Checks if a new piece has been detected."""
        if col is not None:
            # Spalte 7 immer mit rechtem Sensor!
            if col == 7:
                color_sensor = right_color_sensor
            else:
                color_sensor = right_color_sensor if col % 2 == 0 else left_color_sensor
            color = await color_sensor.color()
            print(f"Sensor color at (column {col}, row {row}): {color}")
            stored_value = self.game_board.getBoardList()[ROW_COUNT - row][col - 1]
            return stored_value == 2 and color in (Color.RED, Color.YELLOW)
        return False

    async def _move_x(self, col_diff):
        """Moves in the X direction (columns)."""
        await drive_motor.run_angle(DRIVE_SPEED, col_diff * COLUMN_STEP,then=Stop.BRAKE)



    async def _move_y(self, row_diff):
        global sensor_motor
        """Moves in the Y direction (row height)."""
        await sensor_motor.run_angle(SENSOR_SPEED, row_diff * ROW_STEP,then=Stop.BRAKE)

    async def _return_to_start(self):
        """Returns to the start position."""
        col = 3.5 # col, where the robot waits to play
        await multitask(
            self._move_x(col - self.robot_position),
            self._move_y(1 - self.sensor_position)
        )
        self.robot_position = 4
        self.sensor_position = 1

# --- Test program ---
async def main():
    print("start")
    game_board = board.board()
    robot = RobotControl(is_player_one=True, game_board=game_board)
    watch = StopWatch()
    for col in [1,2,2,6,6,6]:
        game_board.play_move(col)
    game_board.print_board()
    detected_piece = await robot.GetMove()
    await robot.PlayMove(5)
    elapsed = watch.time()
    print("Vergangene Zeit:", elapsed, "ms")
    print("New piece detected at column:", detected_piece)

if __name__ == "__main__":
    run_task(main())

[laurensvalk]

The error is similar to this issue. In his case, it was a bad cable. Is it possible to rule that our for your setup, or could it be the same?

[yannerous]

Good news!
I have fixed the issue by reducing the number of times I call the garbage collector to only when a memory exception happens, instead of every step of my recursive evaluation function.
Sadly, this reduces the number of positions I can evaluate before the memory is full. But it stops it from crashing.

If you want to look further into this issue, I think I could make a Hardware independent version of my Code quite easily. But this is good enough for me and I would mark it as resolved.

Thank you for your time!

[laurensvalk]

If it's not too much trouble, I would love to be able to reproduce the issue somehow.

Ideally memory issues only slow down user code (with user optimization possible as you did), but never cause hardware components to fail 😄

[dlech]

I have fixed the issue by reducing the number of times I call the garbage collector to only when a memory exception happens, instead of every step of my recursive evaluation function.

FYI, on PrimeHub, you can also use gc.threshold() to help mitigate memory fragmentation instead of manually calling gc.collect().

I didn't see in your code though where you have a recursive function.

[yannerous]

Here is the version with only 3 Motors on Ports D,E,F:
pybricks-backup-2025-05-20_14-10-53.zip
The GamemasterGC file is the main file, which always crashes on my Hub when it tries to move after calculating for 60s

I'll take a closer look into garbage collection once I have ironed out some other kinks in the logic :)

[BertLindeman]

Ran on firmware 'primehub', '3.6.1', 'ci-build-3821-v3.6.1-159-gdfbcfa83 on 2025-05-19
showing after ~ 1 minute (repeatable):

Hashmap Elements: 951
stack: 1324 out of 34304
GC: total: 249024, used: 213488, free: 35536
 No. of 1-blocks: 8508, 2-blocks: 486, max blk sz: 612, max free sz: 1854
Background finished
4 98970.0
7 100030.0
5 3980
1 0
3 0
2 10
6 10
Traceback (most recent call last):
  File "GamemasterGC.py", line 86, in <module>
  File "GamemasterGC.py", line 50, in Mainloop
  File "RobotControlGC.py", line 50, in PlayMove
  File "RobotControlGC.py", line 84, in _move_x
OSError: [Errno 1] EPERM: 

The requested operation is not valid in the current state:
--> Check the documentation for required conditions.
--> Check the line in your script that matches
    the line number given in the 'Traceback' above.

[EDIT]
The hub animation stutters a bit sometimes.