mpf 0.80.0.dev12__tar.gz → 0.80.0.dev14__tar.gz

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/.github/workflows/build_wheels.yml

@@ -22,11 +22,13 @@ jobs:
       - name: Setup python
         uses: actions/setup-python@v5
         with:
-          python-version: 3.12
+          python-version: 3.13
 
       - name: Install MPF
         run: |
-          sudo apt-get install -y libjpeg-dev
+          sudo apt-get update
+          sudo apt-get install -y '^libxcb.*-dev' libx11-xcb-dev libjpeg-dev
+          sudo apt-get install -y qt6-base-dev
           pip install --upgrade pip setuptools wheel build
           pip install -e .
 

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/.github/workflows/prospector.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Setup python
         uses: actions/setup-python@v4
         with:
-          python-version: 3.12
+          python-version: 3.13
 
       - name: Install MPF
         run: |

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/.github/workflows/run_tests.yml

@@ -71,6 +71,7 @@ jobs:
           else #must be mac!
             brew install libjpeg-turbo
           fi
+
       - name: Install MPF
         run: |
           pip install --upgrade pip setuptools wheel build coveralls
@@ -106,4 +107,4 @@ jobs:
         pip3 install --upgrade coveralls
         coveralls --service=github --finish
       env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpf
-Version: 0.80.0.dev12
+Version: 0.80.0.dev14
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -35,7 +35,7 @@ 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==11.3.0
+Requires-Dist: Pillow>=11.3.0
 Provides-Extra: crash-reporter
 Requires-Dist: requests==2.28.2; extra == "crash-reporter"
 Provides-Extra: irc
@@ -53,9 +53,9 @@ Requires-Dist: apigpio-mpf==0.0.4; extra == "rpi"
 Provides-Extra: uvloop
 Requires-Dist: uvloop==0.19.0; extra == "uvloop"
 Provides-Extra: vpe
-Requires-Dist: grpcio_tools==1.34.0; extra == "vpe"
-Requires-Dist: grpcio==1.34.0; extra == "vpe"
-Requires-Dist: protobuf==3.14.0; extra == "vpe"
+Requires-Dist: grpcio_tools==1.69.0; extra == "vpe"
+Requires-Dist: grpcio==1.69.0; extra == "vpe"
+Requires-Dist: protobuf==5.29.3; extra == "vpe"
 Provides-Extra: all
 Requires-Dist: prompt_toolkit==3.0.43; extra == "all"
 Requires-Dist: asciimatics==1.15.0; extra == "all"
@@ -66,11 +66,10 @@ Requires-Dist: smbus2_asyncio==0.0.5; extra == "all"
 Requires-Dist: python-osc==1.8.3; extra == "all"
 Requires-Dist: pyusb==1.1.0; extra == "all"
 Requires-Dist: apigpio-mpf==0.0.4; extra == "all"
-Requires-Dist: grpcio_tools==1.34.0; extra == "all"
-Requires-Dist: grpcio==1.34.0; extra == "all"
-Requires-Dist: protobuf==3.14.0; extra == "all"
+Requires-Dist: grpcio_tools==1.69.0; extra == "all"
+Requires-Dist: grpcio==1.69.0; extra == "all"
+Requires-Dist: protobuf==5.29.3; extra == "all"
 Requires-Dist: uvloop==0.19.0; extra == "all"
-Requires-Dist: numpy>=1.7.0; extra == "all"
 Dynamic: license-file
 
 Mission Pinball Framework (MPF)

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.80.0.dev12'
+__version__ = '0.80.0.dev14'
 '''The full version of MPF.'''
 
 __short_version__ = '0.80'

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/config_spec.yaml

@@ -1023,6 +1023,7 @@ multiballs:
     shoot_again: single|template_ms|10s
     hurry_up_time: single|template_ms|0
     grace_period: single|template_ms|0
+    restart_grace_period: single|template_ms|0
     ball_locks: list|machine(ball_devices)|None
     enable_events: event_handler|event_handler:ms|None
     disable_events: event_handler|event_handler:ms|None
@@ -1319,6 +1320,8 @@ score_reel_groups:
     __type__: device
     reels: list|machine(score_reels)|
     chimes: list|machine(coils)|None
+    enable_chimes_events: event_handler|event_handler:ms|ball_started
+    disable_chimes_events: event_handler|event_handler:ms|game_ended
     lights_tag: single|str|None
 segment_displays:
     __valid_in__: machine
@@ -1738,6 +1741,7 @@ sequence_shots:
     delay_event_list: event_handler|event_handler:ms|None
     sequence_timeout: single|ms|0
     playfield: single|machine(playfields)|None
+    allow_multiple_active: single|bool|true
 switches:
     __valid_in__: machine
     __type__: device
@@ -1886,11 +1890,6 @@ widget_player:
     tokens: dict|str:str|None
     x: single|int|0
     y: single|int|0
-video_control_events:
-    action: single|enum(play,pause,stop,seek,volume,position)|
-    event: single|event_handler|
-    value: single|float|None
-
 window:
     __valid_in__: machine
     __type__: config

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/core/clock.py

@@ -64,21 +64,27 @@ class ClockBase(LogMixin):
 
         self.debug_log("Starting tickless clock")
         if not loop:
-            self.loop = self._create_event_loop()   # type: asyncio.AbstractEventLoop
+            self.loop = self._get_or_create_loop()  # type: asyncio.AbstractEventLoop
         else:
             self.loop = loop                        # type: asyncio.AbstractEventLoop
 
         asyncio.set_event_loop(self.loop)
 
-    def _create_event_loop(self):
+    def _get_or_create_loop(self):
+        try:
+            return asyncio.get_event_loop()
+        except RuntimeError:
+            return self._create_loop()
+
+    def _create_loop(self):
         try:
             # pylint: disable-msg=import-outside-toplevel
             import uvloop
         except ImportError:
             pass
         else:
-            asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-        return asyncio.get_event_loop()
+            return uvloop.new_event_loop()
+        return asyncio.new_event_loop()
 
     def run(self, stop_future):
         """Run the clock."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/core/events.py

@@ -900,7 +900,31 @@ class QueuedEvent:
 
 
 def event_handler(relative_priority):
-    """Decorate an event handler."""
+    """Decorate an event handler.
+
+    Priority order is important for a complex device management reason -
+    handler resolution across multiple devices, especially of the same type.
+
+    Say you have two flipper definitions on the same switch and coil pairing, for
+    example with a "weak flipper" mode. Flippers are managed through enable and
+    disable events that are bound through create_machinewide_device_control_events
+    reading their enable_events and disable_events configs.
+
+    There is no way to provide priority adjustment to these events, so if the
+    normal flipper uses "start_weak_flippers" as its disable event, and the
+    weak flipper uses that as its enable event, then you have a tie and thus
+    ambiguous resolution order to the two handlers that will manage the current
+    rule on the coil.
+
+    What would generally be expected is that the weak flipper would win there,
+    meaning the enable-weak must win. But to do that, it must go _last_. So
+    therefore the _disable_ event handler needs a higher priority than the
+    enable handler.
+
+    Therefore the best practice with choosing event_handler relative_priority
+    is to put destructive/cleanup handlers at higher priority, and
+    positive/enabling handlers at lower priority.
+    """
     def decorator(func):
         """Decorate a function with relative priority."""
         func.relative_priority = relative_priority

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/core/randomizer.py

@@ -6,7 +6,7 @@ class Randomizer:
 
     """Generic list randomizer."""
 
-    def __init__(self, items, machine=None, template_type=None):
+    def __init__(self, items, machine=None, template_type='event'):
         """Initialize Randomizer."""
         self.fallback_value = None
         self.force_different = True
@@ -107,25 +107,45 @@ class Randomizer:
             self.force_all = True
 
     def _next_not_random(self, conditional_args):
-        if self.data['current_item_index'] == len(self.items):
+        total_items = len(self.items)
+        current_item_index = self.data['current_item_index']
+
+        if current_item_index >= total_items:
             if not self.loop:
                 raise StopIteration
 
-            self.data['current_item_index'] = 0
+            current_item_index %= total_items  # or we could just go to 0
 
-        self.data['current_item'] = (
-            self._get_items(conditional_args)[self.data['current_item_index']][0])
+        next_item_index = current_item_index
 
-        self.data['current_item_index'] += 1
+        rotated_option_list = self.items[next_item_index:] + self.items[:next_item_index]
+        found_it = False
+        while len(rotated_option_list):
+            next_item = rotated_option_list.pop(0)
+            next_item_index += 1
+            event = next_item[0]
+            if not event.condition or (self._template_type and event.condition.evaluate(conditional_args)):
+                found_it = True
+                break
 
-        return self.data['current_item']
+        if not found_it and self.fallback_value:
+            self.data['current_item'] = self.fallback_value
+            self.data['current_item_index'] = 0
+            return self.fallback_value
+
+        self.data['current_item'] = next_item
+        self.data['current_item_index'] = next_item_index
+
+        return next_item[0].name
 
     @staticmethod
     def _init_data(data_dict):
         """Initialize dict."""
         data_dict['current_item'] = None
         data_dict['items_sent'] = set()
-        data_dict['current_item_index'] = 0  # only used with disable random
+
+        # only used with disable random, represents the index in the list _before_ conditional evaluation check
+        data_dict['current_item_index'] = 0
 
     def get_current(self):
         """Return current item."""
@@ -140,13 +160,13 @@ class Randomizer:
 
     def _get_items(self, conditional_args):
         if self._template_type:
-            conditional_items = list()
+            valid_items = list()
             for event, weight in self.items:
                 if not event.condition:
-                    conditional_items.append((event.name or event, weight))
+                    valid_items.append((event.name or event, weight))
                 elif event.condition.evaluate(conditional_args):
-                    conditional_items.append((event.name, weight))
-            return conditional_items
+                    valid_items.append((event.name, weight))
+            return valid_items
         return self.items
 
     @staticmethod

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/ball_hold.py

@@ -9,7 +9,7 @@ from mpf.core.mode_device import ModeDevice
 from mpf.core.system_wide_device import SystemWideDevice
 
 
-@DeviceMonitor("balls_held")
+@DeviceMonitor("balls_held", "enabled")
 class BallHold(EnableDisableMixin, SystemWideDevice, ModeDevice):
 
     """Ball hold device which can be used to keep balls in ball devices and control their eject later on."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/ball_routing.py

@@ -17,7 +17,7 @@ if MYPY:   # pragma: no cover
     from mpf.core.machine import MachineController   # pylint: disable-msg=cyclic-import,unused-import
 
 
-@DeviceMonitor("balls_routing")
+@DeviceMonitor("balls_routing", "enabled")
 class BallRouting(EnableDisableMixin, ModeDevice):
 
     """Route balls from one device to another when captured."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/multiball.py

@@ -9,7 +9,7 @@ from mpf.core.placeholder_manager import NativeTypeTemplate
 from mpf.core.system_wide_device import SystemWideDevice
 
 
-@DeviceMonitor("shoot_again", "grace_period", "hurry_up", "balls_added_live", "balls_live_target")
+@DeviceMonitor("shoot_again", "grace_period", "hurry_up", "balls_added_live", "balls_live_target", "enabled")
 class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
 
     """Multiball device for MPF."""
@@ -168,11 +168,9 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
         This is started for both beginning multiball ball save and add a ball ball save
         """
         if shoot_again_ms > 0:
-            self.debug_log('Starting ball save timer: %ss',
-                           shoot_again_ms)
+            self.debug_log('Starting ball save timer: %ss', shoot_again_ms)
             self.delay.add(name='disable_shoot_again',
-                           ms=(shoot_again_ms +
-                               grace_period_ms),
+                           ms=(shoot_again_ms + grace_period_ms),
                            callback=self.stop)
         if grace_period_ms > 0:
             self.grace_period = True
@@ -182,8 +180,7 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
         if hurry_up_time_ms > 0:
             self.hurry_up = True
             self.delay.add(name='hurry_up',
-                           ms=(shoot_again_ms -
-                               hurry_up_time_ms),
+                           ms=(shoot_again_ms - hurry_up_time_ms),
                            callback=self._hurry_up)
 
     def _hurry_up(self) -> None:
@@ -237,15 +234,35 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
         desc: The multiball called (name) has lost a ball after ball save expired.
         '''
 
-        if not self.machine.game or self.machine.game.balls_in_play - balls < 1:
-            self.balls_added_live = 0
-            self.balls_live_target = 0
-            self.machine.events.remove_handler(self._ball_drain_count_balls)
-            self.machine.events.post("multiball_{}_ended".format(self.name))
-            '''event: multiball_(name)_ended
-            desc: The multiball called (name) has just ended.
-            '''
-            self.debug_log("Ball drained. MB ended.")
+        restart_grace_period_ms = self.config['restart_grace_period'].evaluate([])
+
+        if not self.machine.game or (self.machine.game.balls_in_play - balls < 1 and restart_grace_period_ms == 0):
+            self._multiball_end()
+        elif restart_grace_period_ms > 0:
+            if self.machine.game.balls_in_play == 0:
+                self.delay.run_now("restart_grace_period")
+            elif self.machine.game.balls_in_play - balls < 1:
+                self.machine.events.post(f"multiball_{self.name}_restart_grace_period_started",
+                                         grace_period=restart_grace_period_ms)
+                '''event: multiball_(name)_restart_grace_period_started
+                desc: The multiball called (name) does not have multiple balls active, enabling grace period.
+                args:
+                    grace_period: restart duration grace period in ms
+                '''
+
+                self.delay.add(name="restart_grace_period",
+                               ms=restart_grace_period_ms,
+                               callback=self._multiball_end)
+
+    def _multiball_end(self):
+        self.balls_added_live = 0
+        self.balls_live_target = 0
+        self.machine.events.remove_handler(self._ball_drain_count_balls)
+        self.machine.events.post("multiball_{}_ended".format(self.name))
+        '''event: multiball_(name)_ended
+        desc: The multiball called (name) has just ended.
+        '''
+        self.debug_log("Ball drained. MB ended.")
 
     @event_handler(5)
     def event_stop(self, **kwargs):
@@ -284,6 +301,14 @@ class Multiball(EnableDisableMixin, SystemWideDevice, ModeDevice):
 
     def add_a_ball(self):
         """Add a ball if multiball has started."""
+        # remove if it exists as multiball now has multiple balls
+        if self.delay.check("restart_grace_period"):
+            self.delay.remove("restart_grace_period")
+            self.machine.events.post(f"multiball_{self.name}_restarted")
+            '''event: multiball_(name)_restarted
+            desc: Multiball (name) has been restarted during end of multiball grace period.
+            '''
+
         if self.balls_live_target > 0:
             self.debug_log("Adding a ball.")
             self.balls_live_target += 1

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/multiball_lock.py

@@ -13,7 +13,7 @@ if MYPY:   # pragma: no cover
     from mpf.devices.playfield import Playfield     # pylint: disable-msg=cyclic-import,unused-import
 
 
-@DeviceMonitor("locked_balls")
+@DeviceMonitor("locked_balls", "enabled")
 class MultiballLock(EnableDisableMixin, ModeDevice):
 
     """Ball lock device which locks balls for a multiball."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/score_reel_group.py

@@ -3,6 +3,7 @@ from collections import deque
 
 from mpf.core.system_wide_device import SystemWideDevice
 from mpf.devices.score_reel_controller import ScoreReelController
+from mpf.core.events import event_handler
 
 
 class ScoreReelGroup(SystemWideDevice):
@@ -52,6 +53,9 @@ class ScoreReelGroup(SystemWideDevice):
         self.jump_in_progress = False
         # Boolean attribute that is True when a jump advance is in progress.
 
+        self.chimes_enabled = False
+        # Boolean attribute that is True when chimes should play when reels advance.
+
         self._tick_task = None
 
     async def _initialize(self):
@@ -69,11 +73,25 @@ class ScoreReelGroup(SystemWideDevice):
                                                 handler=self.chime,
                                                 chime=self.config['chimes'][i])
 
-    @classmethod
-    def chime(cls, chime, **kwargs):
-        """Pulse chime."""
+    def chime(self, chime, **kwargs):
+        """Pulse chime if chimes are enabled."""
+        del kwargs
+        if self.chimes_enabled:
+            chime.pulse()
+
+    @event_handler(1)
+    def event_enable_chimes(self, **kwargs):
+        """Event handler to enable chimes."""
+        del kwargs
+        self.chimes_enabled = True
+        self.log.info('Chimes enabled.')
+
+    @event_handler(2)
+    def event_disable_chimes(self, **kwargs):
+        """Event handler to disable chimes."""
         del kwargs
-        chime.pulse()
+        self.chimes_enabled = False
+        self.log.info('Chimes disabled.')
 
     def set_value(self, value):
         """Reset the score reel group to display the value passed.

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/sequence_shot.py

@@ -21,7 +21,8 @@ class SequenceShot(SystemWideDevice, ModeDevice):
     collection = 'sequence_shots'
     class_label = 'sequence_shot'
 
-    __slots__ = ["delay", "active_sequences", "active_delays", "_sequence_events", "_delay_events", "_start_time"]
+    __slots__ = ["delay", "active_sequences", "active_delays", "_sequence_events", "_delay_events",
+                 "_allow_multiple_active", "_start_time"]
 
     def __init__(self, machine, name):
         """Initialize sequence shot."""
@@ -33,6 +34,7 @@ class SequenceShot(SystemWideDevice, ModeDevice):
 
         self._sequence_events = []      # type: List[str]
         self._delay_events = {}         # type: Dict[str, int]
+        self._allow_multiple_active = None
         self._start_time = None
 
     @property
@@ -63,17 +65,19 @@ class SequenceShot(SystemWideDevice, ModeDevice):
             raise AssertionError("Sequence shot {} only supports switch_sequence or event_sequence".format(self.name))
 
         self._sequence_events = self.config['event_sequence']
+        self._allow_multiple_active = self.config['allow_multiple_active']
 
         for switch in self.config['switch_sequence']:
             self._sequence_events.append(self.machine.switch_controller.get_active_event_for_switch(switch.name))
 
     def _register_handlers(self):
+        # use "set" to dedupe events. They must be registered once
         for event in set(self._sequence_events):
             self.machine.events.add_handler(event, self._sequence_advance, event_name=event)
 
         for switch in self.config['cancel_switches']:
             self.machine.switch_controller.add_switch_handler_obj(
-                switch, self.event_cancel, 1)
+                switch, self.event_cancel, 1, return_info=True)
 
         for switch, ms in list(self.config['delay_switch_list'].items()):
             self.machine.switch_controller.add_switch_handler_obj(
@@ -106,22 +110,27 @@ class SequenceShot(SystemWideDevice, ModeDevice):
 
         self.debug_log("Sequence advance: %s", event_name)
 
-        if event_name == self._sequence_events[0]:
-            if len(self._sequence_events) > 1:
-                # start a new sequence
-                self._start_new_sequence()
-            elif not self.active_delays:
-                # if it only has one step it will finish right away
-                self._completed()
-        else:
-            # Get the seq_id of the first sequence this switch is next for.
-            # This is not a loop because we only want to advance 1 sequence
-            seq = next((x for x in self.active_sequences if
-                        x.next_event == event_name), None)
+        # Get the sequences that have next_event set to this event_name.
+        # This is not a loop because we only want to advance 1 sequence
+        # (the most advanced one, so we sort and select the greater one)
 
-            if seq:
-                # advance this sequence
-                self._advance_sequence(seq)
+        seqs = [x for x in self.active_sequences if x.next_event == event_name]
+        seqs.sort(key=lambda _: _.current_position_index)
+        if len(seqs) >= 1:
+            # advance this sequence
+            self._advance_sequence(seqs[-1])
+
+        # create new sequence (this must be done after new sequence creation)
+        # otherwise if the first two elements are same, the sequence will be created
+        # and advanced !
+        if event_name == self._sequence_events[0]:
+            if len(self.active_sequences) == 0 or self._allow_multiple_active:
+                if len(self._sequence_events) > 1:
+                    # start a new sequence
+                    self._start_new_sequence()
+                elif not self.active_delays:
+                    # if it only has one step it will finish right away
+                    self._completed()
 
     def _start_new_sequence(self):
         # If the sequence hasn't started, make sure we're not within the
@@ -188,8 +197,12 @@ class SequenceShot(SystemWideDevice, ModeDevice):
     @event_handler(0)
     def event_cancel(self, **kwargs):
         """Event handler for cancel event."""
-        del kwargs
-        self.reset_all_sequences()
+        if 'switch_name' in kwargs:
+            switch = kwargs['switch_name']
+            seqs = [x for x in self.active_sequences if x.next_event == f'{switch}_active']
+            self.active_sequences = list(seqs)
+        else:
+            self.reset_all_sequences()
 
     def reset_all_sequences(self):
         """Reset all sequences."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/shot.py

@@ -10,7 +10,7 @@ from mpf.core.mode_device import ModeDevice
 from mpf.core.player import Player
 
 
-@DeviceMonitor("state", "state_name")
+@DeviceMonitor("state", "state_name", "enabled")
 class Shot(EnableDisableMixin, ModeDevice):
 
     """A device which represents a generic shot."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/devices/spinner.py

@@ -13,7 +13,7 @@ if MYPY:   # pragma: no cover
     from mpf.core.machine import MachineController  # pylint: disable-msg=cyclic-import,unused-import
 
 
-@DeviceMonitor(_active="active", _idle="idle")
+@DeviceMonitor(_active="active", _idle="idle", enabled="enabled")
 class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     """Represents a spinner or spinner group in a pinball machine."""

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/platforms/opp/opp_incand.py

@@ -53,6 +53,8 @@ class OPPIncand(LightPlatformSoftwareFade):
         super().__init__(number, loop, hardware_fade_ms)
         self.incand_card = incand_card  # type: OPPIncandCard
         self.index = int(number)
+        self.number = incand_card.chain_serial + "-" + \
+            incand_card.card_num + '-' + str(number)
 
     def set_brightness(self, brightness: float):
         """Enable (turns on) this driver.

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/platforms/p_roc_devices.py

@@ -117,7 +117,7 @@ class PROCDriver(DriverPlatformInterface):
             self.platform.run_proc_cmd_no_wait("driver_patter", self.number, pwm_on, pwm_off,
                                                pulse_settings.duration, True)
         else:
-            self.log.debug('Enabling at 100%')
+            self.log.debug("Enabling at 100 percent!")
 
             self.platform.run_proc_cmd_no_wait("driver_schedule", self.number, 0xffffffff, 0, True)
 

{mpf-0.80.0.dev12 → mpf-0.80.0.dev14}/mpf/platforms/virtual.py

@@ -303,6 +303,11 @@ class VirtualHardwarePlatform(AccelerometerPlatform, I2cPlatform, ServoPlatform,
         self._assert_rule_does_not_exist(enable_switch.hw_switch, coil.hw_driver)
         self.rules[(enable_switch.hw_switch, coil.hw_driver)] = "pulse_on_hit"
 
+    def set_delayed_pulse_on_hit_rule(self, enable_switch, coil, delay_ms):
+        """Set pulse on hit after delay rule, typical of kickbacks."""
+        self._assert_rule_does_not_exist(enable_switch.hw_switch, coil.hw_driver)
+        self.rules[(enable_switch.hw_switch, coil.hw_driver)] = "delayed_pulse_on_hit"
+
     def configure_dmd(self):
         """Configure DMD."""
         return VirtualDmd()