mpf 0.57.4.dev1__tar.gz → 0.57.4.dev2__tar.gz

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.4.dev1
+Version: 0.57.4.dev2
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -31,6 +31,7 @@ Requires-Dist: psutil==5.9.8
 Requires-Dist: pyserial==3.5
 Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: ruamel.yaml==0.18.6
+Requires-Dist: setuptools~=72.2.0
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
 Requires-Dist: Pillow==9.5.0

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.57.4.dev1'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.57.4.dev2'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
 __short_version__ = '0.57'

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/config_spec.yaml

@@ -748,6 +748,9 @@ fast_servos:
     min_us: single|int|1000
     home_us: single|int|1500
     max_runtime: single|ms|2000  # 65535 max
+fast_stepper_settings:
+    __valid_in__: machine                 # todo add to validator
+    default_speed: single|int|600
 file_shows:
     __valid_in__: machine, mode                      # todo add to validator
     __type__: config_dict
@@ -1941,23 +1944,28 @@ spinners:
 steppers:
     __valid_in__: machine
     __type__: device
-    named_positions: dict|float:str|None
     home_events: event_handler|event_handler:ms|None
+    home_on_startup: single|bool|true
     homing_mode: single|enum(hardware,switch)|hardware
     homing_switch: single|machine(switches)|None
     homing_direction: single|enum(clockwise,counterclockwise)|clockwise
+    homing_speed: single|int|None
     pos_min: single|int|0
     pos_max: single|int|1000
     ball_search_min: single|int|0
     ball_search_max: single|int|1
     ball_search_wait: single|ms|5s
     include_in_ball_search: single|bool|true
-    relative_positions: dict|float:str|None
+    relative_positions: dict|float:subconfig(stepper_position_settings)|None
     reset_position: single|int|0
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting, ball_will_end, service_mode_entered
+    named_positions: dict|float:subconfig(stepper_position_settings)|None
     number: single|str|
     platform: single|str|None
     platform_settings: single|dict|None
+stepper_position_settings:
+    event: single|str|
+    speed: single|int|None
 spike_stepper_settings:
     homing_speed: single|int|10
     speed: single|int|20

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/core/text_ui.py

@@ -351,8 +351,11 @@ class TextUi(MpfController):
         self._machine_widgets.append(Label("MACHINE VARIABLES"))
         self._machine_widgets.append(Divider())
         machine_vars = self.machine.variables.machine_vars
-        # If config defines explict vars to show, only show those. Otherwise, all
-        names = self.config.get('machine_vars', machine_vars.keys())
+        # If config defines explict vars to show, only show those.
+        # Otherwise, filter out the unhelpful defaults
+        names = self.config.get('machine_vars', [n for n in machine_vars.keys() if not (
+            n.startswith("audits") or n.startswith("platform") or n.startswith("mpf"))
+        ])
         for name in names:
             self._machine_widgets.append(Label("{}: {}".format(name, machine_vars[name]['value'])))
         self._layout_change = True

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/devices/servo.py

@@ -80,8 +80,10 @@ class Servo(SystemWideDevice):
 
         This should either home the servo or disable the output.
         """
-        self.debug_log("Stopping servo")
-        self.hw_servo.stop()
+        # A crash may occur during startup before hw_servo is instantiated
+        if self.hw_servo:
+            self.debug_log("Stopping servo")
+            self.hw_servo.stop()
 
     @event_handler(5)
     def _position_event(self, position, **kwargs):

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/devices/stepper.py

@@ -26,7 +26,8 @@ class Stepper(SystemWideDevice):
     class_label = 'stepper'
 
     __slots__ = ["hw_stepper", "_target_position", "_current_position", "_ball_search_started",
-                 "_ball_search_old_target", "_is_homed", "_is_moving", "_move_task", "delay"]
+                 "_ball_search_old_target", "_is_homed", "_is_moving", "_move_task", "delay",
+                 "_target_speed"]
 
     def __init__(self, machine, name):
         """Initialize stepper."""
@@ -34,6 +35,7 @@ class Stepper(SystemWideDevice):
         self.platform = None            # type: Optional[Stepper]
         self._target_position = 0       # in user units
         self._current_position = 0      # in user units
+        self._target_speed = None       # in steps per second
         self._ball_search_started = False
         self._ball_search_old_target = 0
         self._is_homed = False
@@ -51,14 +53,16 @@ class Stepper(SystemWideDevice):
         self._target_position = self.config['reset_position']
 
         for position in self.config['named_positions']:
-            self.machine.events.add_handler(self.config['named_positions'][position],
+            self.machine.events.add_handler(self.config['named_positions'][position]['event'],
                                             self.event_move_to_position,
-                                            position=position)
+                                            position=position,
+                                            speed=self.config['named_positions'][position]['speed'])
 
         for position in self.config['relative_positions']:
-            self.machine.events.add_handler(self.config['relative_positions'][position],
+            self.machine.events.add_handler(self.config['relative_positions'][position]['event'],
                                             self.event_move_to_position,
                                             position=position,
+                                            speed=self.config['relative_positions'][position]['speed'],
                                             is_relative=True)
 
         if not self.platform.features['allow_empty_numbers'] and self.config['number'] is None:
@@ -82,6 +86,13 @@ class Stepper(SystemWideDevice):
 
     def validate_and_parse_config(self, config, is_mode_config, debug_prefix: str = None):
         """Validate stepper config."""
+        # If positions are just strings, expand them into strings and speeds
+        # TODO: Figure out how to use express_config() to map this
+        for cfg in ('named_positions', 'relative_positions'):
+            if cfg in config:
+                for pos, value in config[cfg].items():
+                    if isinstance(value, str):
+                        config[cfg][pos] = {'event': value}
         config = super().validate_and_parse_config(config, is_mode_config, debug_prefix)
         platform = self.machine.get_platform_sections(
             'stepper_controllers', getattr(config, "platform", None))
@@ -94,9 +105,13 @@ class Stepper(SystemWideDevice):
         # wait for switches to be initialized
         await self.machine.events.wait_for_event("init_phase_3")
 
-        # first home the stepper
-        self.info_log("Initializing stepper and homing.")
-        await self._home()
+        if self.config['home_on_startup']:
+            # first home the stepper
+            self.info_log("Initializing stepper and homing.")
+            await self._home()
+        else:
+            self.info_log("Initializing stepper but will not home.")
+            self._is_homed = True
 
         # run the loop at least once
         self._is_moving.set()
@@ -119,7 +134,10 @@ class Stepper(SystemWideDevice):
                 self.info_log("Stepper moving relative %s to hit target %s from %s",
                               delta, target_position, self._current_position)
                 # move stepper
-                self.hw_stepper.move_rel_pos(delta)
+                self.hw_stepper.move_rel_pos(delta, self._target_speed)
+                # Clear the speed override here, in case a subsequent move wants
+                # to set one before this one finishes.
+                self._target_speed = None
                 # wait for the move to complete
                 await self.hw_stepper.wait_for_move_completed()
             else:
@@ -130,12 +148,13 @@ class Stepper(SystemWideDevice):
             # post ready event
             self._post_ready_event()
 
-    def _move_to_absolute_position(self, position):
+    def _move_to_absolute_position(self, position, speed=None):
         """Move stepper to position."""
         self.info_log("Moving to absolute position %s. Current position: %s",
-                      self.hw_stepper, position, self._current_position)
+                      position, self._current_position)
         if self.config['pos_min'] <= position <= self.config['pos_max']:
             self._target_position = position
+            self._target_speed = speed
             self._is_moving.set()
         else:
             raise ValueError("_move_to_absolute_position: position argument beyond limits")
@@ -176,7 +195,9 @@ class Stepper(SystemWideDevice):
 
     def stop_device(self):
         """Stop motor."""
-        self.hw_stepper.stop()
+        # A crash during startup may not have initialized the hw_stepper yet
+        if self.hw_stepper:
+            self.hw_stepper.stop()
         self._is_moving.clear()
         if self._move_task:
             self._move_task.cancel()
@@ -201,22 +222,22 @@ class Stepper(SystemWideDevice):
         self._move_to_absolute_position(self.config['reset_position'])
 
     @event_handler(5)
-    def event_move_to_position(self, position=None, is_relative=False, **kwargs):
+    def event_move_to_position(self, position=None, speed=None, is_relative=False, **kwargs):
         """Event handler for move_to_position event."""
         del kwargs
         if position is None:
             raise AssertionError("move_to_position event is missing a position.")
 
-        self.move_to_position(position, is_relative)
+        self.move_to_position(position, speed, is_relative)
 
-    def move_to_position(self, position, is_relative=False):
+    def move_to_position(self, position, speed=None, is_relative=False):
         """Move stepper to a position."""
         self.info_log("Stepper at %s moving to %s position %s", self._current_position,
                       "relative" if is_relative else "absolute", position)
         self._target_position = (self._current_position + position) if is_relative else position
         if self._ball_search_started:
             return
-        self._move_to_absolute_position(self._target_position)
+        self._move_to_absolute_position(self._target_position, speed)
 
     def _ball_search_start(self, **kwargs):
         del kwargs

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/fast/communicators/exp.py

@@ -1,6 +1,8 @@
 """FAST Expansion Board Serial Communicator."""
 # mpf/platforms/fast/communicators/exp.py
 
+from functools import partial
+
 from mpf.platforms.fast.fast_defines import EXPANSION_BOARD_FEATURES
 from mpf.platforms.fast.fast_exp_board import FastExpansionBoard
 from mpf.platforms.fast.communicators.base import FastSerialCommunicator
@@ -18,14 +20,16 @@ class FastExpCommunicator(FastSerialCommunicator):
 
     IGNORED_MESSAGES = ['XX:F']
 
-    __slots__ = ["exp_boards_by_address", "active_board"]
+    __slots__ = ["exp_boards_by_address", "active_board", "_device_processors"]
 
     def __init__(self, platform, processor, config):
         """Initialize the EXP communicator."""
         super().__init__(platform, processor, config)
 
         self.exp_boards_by_address = dict()  # keys = board addresses, values = FastExpansionBoard objects
+        self._device_processors = dict()
         self.active_board = None
+
         self.message_processors['BR:'] = self._process_br
 
     async def init(self):
@@ -104,3 +108,20 @@ class FastExpCommunicator(FastSerialCommunicator):
 
         self.platform.debug_log("%s - Setting LED fade rate to %sms", self, rate)
         self.send_and_forget(f'RF@{board_address}:{Util.int_to_hex_string(rate, True)}')
+
+    def register_processor(self, message_prefix, board_address, device_id, callback):
+        """Register an exp board processor to handle messages."""
+        if message_prefix not in self.message_processors:
+            self.message_processors[message_prefix] = partial(self._process_device_msg, message_prefix)
+            self._device_processors[message_prefix] = dict()
+        if board_address not in self._device_processors[message_prefix]:
+            self._device_processors[message_prefix][board_address] = dict()
+        self._device_processors[message_prefix][board_address][device_id] = callback
+
+    def _process_device_msg(self, message_prefix, message):
+        # Commands like MS: currently don't include the EXP board in the response,
+        # so there's no way to know which board needs to be informed. Inform them
+        # all? If multiple boards are running concurrently, it'll get ugly.
+        device_id = message.split(",")[0]
+        for board_callback in self._device_processors[message_prefix].values():
+            board_callback[device_id](message)

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/fast/fast.py

@@ -8,6 +8,7 @@ from serial import SerialException
 from mpf.core.platform import (RgbDmdPlatform, DriverConfig, DriverSettings,
                                LightsPlatform, RepulseSettings,
                                SegmentDisplayPlatform, ServoPlatform,
+                               StepperPlatform,
                                SwitchConfig, SwitchSettings)
 from mpf.core.utility_functions import Util
 from mpf.exceptions.config_file_error import ConfigFileError
@@ -24,6 +25,7 @@ from mpf.platforms.fast.fast_light import FASTMatrixLight
 from mpf.platforms.fast.fast_port_detector import FastPortDetector
 from mpf.platforms.fast.fast_segment_display import FASTSegmentDisplay
 from mpf.platforms.fast.fast_servo import FastServo
+from mpf.platforms.fast.fast_stepper import FastStepper
 from mpf.platforms.fast.fast_switch import FASTSwitch
 # pylint: disable-msg=too-many-instance-attributes
 from mpf.platforms.interfaces.light_platform_interface import LightPlatformInterface
@@ -31,7 +33,7 @@ from mpf.platforms.system11 import System11OverlayPlatform
 
 
 class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
-                           SegmentDisplayPlatform,
+                           SegmentDisplayPlatform, StepperPlatform,
                            System11OverlayPlatform):
 
     """Platform class for the FAST Pinball hardware."""
@@ -428,6 +430,41 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
 
         return FastServo(brk_board, port, config)
 
+    async def configure_stepper(self, number: str, config: dict) -> FastStepper:
+        """Configure a servo.
+
+        Args:
+        ----
+            number: Number of stepper
+            config: Dict of config settings.
+
+        Returns: Stepper object.
+        """
+        # TODO consolidate with similar code in configure_light()
+        number = number.lower()
+        parts = number.split("-")
+
+        exp_board = self.exp_boards_by_name[parts[0]]
+
+        try:
+            _, port = parts
+            breakout_id = '0'
+        except ValueError:
+            _, breakout_id, port = parts
+            breakout_id = breakout_id.strip('b')
+
+        brk_board = exp_board.breakouts[breakout_id]
+
+        # verify this board support servos
+        assert int(port) <= int(brk_board.features['stepper_ports'])  # TODO should this be stored as an int?
+
+        return FastStepper(brk_board, port, config)
+
+    @classmethod
+    def get_stepper_config_section(cls):
+        """Return config section."""
+        return "fast_stepper_settings"
+
     def _parse_switch_number(self, number):
         try:
             board_str, switch_str = number.split("-")

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/fast/fast_defines.py

@@ -27,6 +27,12 @@ VALID_IO_BOARDS = (
 )
 
 EXPANSION_BOARD_FEATURES = {
+    'FP-EXP-0061': {
+        'min_fw': '0.31',
+        'local_breakouts': ['FP-EXP-0061'],
+        'breakout_ports': 0,
+        'default_address': '90'
+    },
     'FP-EXP-0071': {
         'min_fw': '0.11',
         'local_breakouts': ['FP-EXP-0071'],
@@ -54,6 +60,11 @@ EXPANSION_BOARD_FEATURES = {
 }
 
 BREAKOUT_FEATURES = {
+    'FP-EXP-0061': {
+        'min_fw': '0.33',
+        'led_ports': 4,
+        'stepper_ports': 2
+    },
     'FP-EXP-0071': {
         'min_fw': '0.11',
         'led_ports': 4,

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/fast/fast_servo.py

@@ -1,4 +1,5 @@
 """Fast servo implementation."""
+
 from mpf.platforms.interfaces.servo_platform_interface import ServoPlatformInterface
 
 
@@ -14,7 +15,7 @@ class FastServo(ServoPlatformInterface):
         self.exp_connection = breakout_board.communicator
 
         self.base_address = breakout_board.address
-        self.servo_index = str(int(port) - 1)  # Servos are 0-indexed
+        self.servo_index = f"{(int(port) - 1):X}"  # Servos are 0-indexed hex
         self.max_runtime = f"{config['max_runtime']:02X}"
 
         self.write_config_to_servo()

mpf-0.57.4.dev2/mpf/platforms/fast/fast_stepper.py

@@ -0,0 +1,111 @@
+"""Fast servo implementation."""
+
+import asyncio
+
+from mpf.core.utility_functions import Util
+from mpf.exceptions.config_file_error import ConfigFileError
+from mpf.platforms.interfaces.stepper_platform_interface import StepperPlatformInterface
+
+POLL_MS = 100
+MIN_SPEED = 350
+MAX_SPEED = 1650
+
+
+class FastStepper(StepperPlatformInterface):
+
+    """A stepper in the FAST platform connected to a FAST Expansion Board."""
+
+    __slots__ = ["base_address", "config", "exp_connection", "log", "stepper_index",
+                 "_is_moving", "_default_speed"]
+
+    def __init__(self, breakout_board, port, config):
+        """Initialize servo."""
+        self.config = config
+        self.exp_connection = breakout_board.communicator
+
+        self.stepper_index = Util.int_to_hex_string(int(port) - 1)  # Steppers are 0-indexed
+        self.base_address = breakout_board.address
+        self.log = breakout_board.log
+
+        self.exp_connection.register_processor('MS:', self.base_address, self.stepper_index, self._process_ms)
+        self._is_moving = False
+        self._default_speed = Util.int_to_hex_string(self.config['default_speed'], True)
+
+    def home(self, direction):
+        """Return the stepper to its home position."""
+        if direction != 'counterclockwise':
+            raise ConfigFileError("FAST Stepper only supports home in counter-clockwise direction. "
+                                  "Please rewire your motor and set homing_direction: counterclockwise "
+                                  "in your stepper config.", 1, self.__class__.__name__)
+        self._is_moving = True
+        self._send_command("MH")
+
+    async def wait_for_move_completed(self):
+        """Wait for the stepper to stop moving."""
+        # If not moving, return immediately
+        if not self._is_moving:
+            return
+        while True:
+            await asyncio.sleep(POLL_MS / 1000)
+            # We may have stopped since the last poll, so check again
+            if not self._is_moving:
+                return
+            self._send_command('MS')
+
+    def move_rel_pos(self, position, speed=None):
+        """Move the servo a relative number of steps position."""
+        if not position:
+            return
+
+        base_command = "MF" if position > 0 else "MR"
+        hex_position = Util.int_to_hex_string(position, True)
+        self.log.info("Moving stepper index %s: %s steps with speed %s", self.stepper_index, position, speed)
+
+        if speed:
+            if speed < MIN_SPEED or speed > MAX_SPEED:
+                raise ConfigFileError("FAST Stepper only supports speeds between 350-1650, "
+                                      f"but received value of {speed}.",
+                                      2, self.__class__.__name__)
+            speed = Util.int_to_hex_string(speed, True)
+        else:
+            speed = self._default_speed
+
+        self._is_moving = True
+        self._send_command(base_command, [hex_position, speed])
+
+    def move_vel_mode(self, velocity):
+        """Move the motor indefinitely in either direction.
+
+        FAST does not support this, so instead send the longest possible move time.
+        """
+        base_command = "MR" if velocity < 0 else "MF"
+        # The only place in MPF code that uses move_vel_mode is the software-based
+        # homing, which sends 1/-1 as values. Interpret that as slowest possible
+        # speed.
+        speed = MIN_SPEED if abs(velocity) == 1 else abs(velocity)
+        self._is_moving = True
+        # Maximum supported move time is FFFF
+        self._send_command(base_command, ["FFFF", speed])
+
+    def stop(self):
+        """Called during shutdown."""
+        self._send_command("MC")
+
+    def set_home_position(self):
+        """Not used."""
+
+    def _send_command(self, base_command, payload=None):
+        if not payload:
+            payload = []
+        self.exp_connection.send_and_forget(','.join([
+            f'{base_command}@{self.base_address}:{self.stepper_index}', *payload]))
+
+    def _process_ms(self, message):
+        _index, state = message.split(",")
+        state_flags = int(state, 16)
+        self._is_moving = state_flags & 1
+        ## Unused
+        # self._is_reversed = state_flags & (1 << 1)
+        # self._is_home = state_flags & (1 << 2)
+        # self._is_limit = state_flags & (1 << 3)
+        # self.is_braked = state_flags & (1 << 4)

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/interfaces/stepper_platform_interface.py

@@ -35,7 +35,7 @@ class StepperPlatformInterface(metaclass=abc.ABCMeta):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move axis to a certain relative position."""
         raise NotImplementedError
 

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/p_roc_devices.py

@@ -487,7 +487,7 @@ class PdLedStepper(StepperPlatformInterface):
         else:
             self.move_rel_pos(-16384)
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move stepper by x steps."""
         if abs(position) > 16384:
             raise ValueError("Cannot move more than 16384 steps but tried {}".format(position))

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/pololu/pololu_tic.py

@@ -189,7 +189,7 @@ class PololuTICStepper(StepperPlatformInterface):
         self._move_complete.clear()
         self.tic.rotate_to_position(self._position)
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move axis to a relative position."""
         self._position += position
         self._move_complete.clear()

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/spike/spike.py

@@ -420,10 +420,10 @@ class SpikeStepper(StepperPlatformInterface):
             return False
         return info['position'] == self._position
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move relative to current position."""
         self._position += int(position)
-        self._move_to_absolute_position(self._position, self.config['speed'])
+        self._move_to_absolute_position(self._position, speed or self.config['speed'])
 
     def move_vel_mode(self, velocity):
         """Move stepper in a direction."""

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/step_stick.py

@@ -35,7 +35,7 @@ class DigitalOutputStepStickStepper(StepperPlatformInterface):
         if self.enable_output:
             self.enable_output.enable()
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move a number of steps in one direction."""
         if self._move_task and not self._move_task.done():
             raise AssertionError("Last move has not been completed. Calls stop first.")

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/trinamics_steprocker.py

@@ -110,7 +110,7 @@ class TrinamicsTMCLStepper(StepperPlatformInterface):
         microstep_pos = self._uu_to_microsteps(position)
         self.tmcl.mvp(self._mn, "ABS", microstep_pos)
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move axis to a relative position."""
         microstep_rel = self._uu_to_microsteps(position)
         self.tmcl.mvp(self._mn, "REL", microstep_rel)

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf/platforms/virtual.py

@@ -60,9 +60,18 @@ class VirtualHardwarePlatform(AccelerometerPlatform, I2cPlatform, ServoPlatform,
 
     async def initialize(self) -> None:
         """Initialize platform."""
+        self.machine.events.add_handler("virtual_platform_set_switch",
+                                        self.virtual_set_switch)
+        self.machine.events.add_handler("virtual_platform_remove_ball_from_device",
+                                        self.virtual_remove_ball_from_device)
+        self.machine.events.add_handler("virtual_platform_add_ball_to_device",
+                                        self.virtual_add_ball_to_device)
 
     def stop(self):
         """Stop platform."""
+        self.machine.events.remove_handler(self.virtual_set_switch)
+        self.machine.events.remove_handler(self.virtual_remove_ball_from_device)
+        self.machine.events.remove_handler(self.virtual_add_ball_to_device)
 
     async def configure_servo(self, number: str, config: dict):
         """Configure a servo device in platform."""
@@ -138,6 +147,50 @@ class VirtualHardwarePlatform(AccelerometerPlatform, I2cPlatform, ServoPlatform,
             platforms.append(Util.string_to_class(platform))
         return platforms
 
+    def _set_ball_device_switch_state(self, ball_device, ball_position, switch_state):
+        if not self.machine.ball_devices.get(ball_device):
+            raise AssertionError(f"Unknown ball device '{ball_device}'")
+        bd = self.machine.ball_devices[ball_device]
+        switches = [s for s in Util.string_to_list(bd.config['ball_switches']) if s != bd.config.get('jam_switch')]
+        # If an explicit switch is designated, deactivate that one.
+        if ball_position >= 0:
+            switch = switches[ball_position]
+        # Otherwise get the next switch to change state
+        else:
+            switches = [s for s in switches if self.machine.switches[s].state != switch_state]
+            # If none are active, do nothing
+            if not switches:
+                return
+            # For removing a ball, choose the LAST switch
+            if not switch_state:
+                switch = switches[-1]
+            # For adding a ball, choose the EARLIEST switch
+            else:
+                switch = switches[0]
+        self.machine.switch_controller.process_switch(switch, switch_state)
+
+    def virtual_set_switch(self, switch, state=-1, **kwargs):
+        """Simulate a switch state change, either to an explicit state or toggle."""
+        del kwargs
+        s = self.machine.switches[switch]
+        if state == -1:
+            state = s.state ^ 1
+        self.machine.switch_controller.process_switch_obj(s, state, True)
+
+    def virtual_remove_ball_from_device(self, ball_device, ball_position=-1, **kwargs):
+        """Remove a ball from a device by deactivating a switch."""
+        del kwargs
+        self._set_ball_device_switch_state(ball_device, ball_position, 0)
+
+    def virtual_add_ball_to_device(self, ball_device, ball_position=-1, **kwargs):
+        """Add a ball from a device by activating a switch.
+
+        This is a simpler version of SmartVirtualPlatform's add_ball_to_device,
+        and should probably not be used on Smart Virtual platform.
+        """
+        del kwargs
+        self._set_ball_device_switch_state(ball_device, ball_position, 1)
+
     def validate_stepper_section(self, stepper, config):
         """Validate stepper sections."""
         return config
@@ -512,7 +565,7 @@ class VirtualStepper(StepperPlatformInterface):
         """Wait until move completed."""
         await asyncio.sleep(0.1)
 
-    def move_rel_pos(self, position):
+    def move_rel_pos(self, position, speed=None):
         """Move axis to a relative position."""
         self._current_position += position
 

{mpf-0.57.4.dev1 → mpf-0.57.4.dev2}/mpf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.4.dev1
+Version: 0.57.4.dev2
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -31,6 +31,7 @@ Requires-Dist: psutil==5.9.8
 Requires-Dist: pyserial==3.5
 Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: ruamel.yaml==0.18.6
+Requires-Dist: setuptools~=72.2.0
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
 Requires-Dist: Pillow==9.5.0