mpf 0.57.2__tar.gz → 0.57.2.dev2__tar.gz

{mpf-0.57.2 → mpf-0.57.2.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.2
+Version: 0.57.2.dev2
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/_version.py

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

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/assets/show.py

@@ -521,7 +521,6 @@ class RunningShow:
     def _start_play(self):
         if self._stopped:
             return
-        self.machine.show_controller.debug_log("Starting show %s", self.show.name)
 
         self._total_steps = len(self.show_steps)
 
@@ -561,7 +560,6 @@ class RunningShow:
         """Stop show."""
         if self._stopped:
             return
-        self.machine.show_controller.debug_log("Stopping show %s", self.show.name)
 
         self._stopped = True
 
@@ -591,14 +589,12 @@ class RunningShow:
 
     def pause(self):
         """Pause show."""
-        self.machine.show_controller.debug_log("Pausing show %s", self.show.name)
         self._remove_delay_handler()
         if self.show_config.events_when_paused:
             self._post_events(self.show_config.events_when_paused)
 
     def resume(self):
         """Resume paused show."""
-        self.machine.show_controller.debug_log("Resuming show %s", self.show.name)
         self.next_step_time = self.machine.clock.get_time()
         self._run_next_step(post_events=self.show_config.events_when_resumed)
 

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/config_spec.yaml

@@ -115,7 +115,7 @@ autofire_coils:
     coil_overwrite: single|subconfig(coil_overwrites)|None
     switch_overwrite: dict|str:str|None
     ball_search_order: single|int|100
-    playfield: single|machine(playfields)|None
+    playfield: single|machine(playfields)|playfield
     timeout_watch_time: single|ms|0
     timeout_max_hits: single|int|0
     timeout_disable_time: single|ms|0
@@ -493,12 +493,11 @@ drop_targets:
     reset_coil_max_wait_ms: single|ms|100ms
     knockdown_coil_max_wait_ms: single|ms|100ms
     ignore_switch_ms: single|ms|500ms
-    playfield: single|machine(playfields)|None
+    playfield: single|machine(playfields)|playfield
 drop_target_banks:
     __valid_in__: machine, mode
     __type__: device
     drop_targets: list|machine(drop_targets)|
-    ball_search_order: single|int|100
     max_reset_attempts: single|int|None
     reset_on_complete: single|ms|None
     reset_coil: single|machine(coils)|None
@@ -506,7 +505,6 @@ drop_target_banks:
     reset_coil_max_wait_ms: single|ms|100ms
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting
     ignore_switch_ms: single|ms|500ms
-    playfield: single|machine(playfields)|playfield
 effects:
     common:
         type: single|str|
@@ -1076,7 +1074,7 @@ magnets:
     release_time: single|ms|500ms
     fling_drop_time: single|ms|250ms
     fling_regrab_time: single|ms|50ms
-    playfield: single|machine(playfields)|None
+    playfield: single|machine(playfields)|playfield
     enable_events: event_handler|event_handler:ms|ball_started
     disable_events: event_handler|event_handler:ms|ball_will_end, service_mode_entered
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting
@@ -1930,7 +1928,6 @@ spinners:
     labels: list|str|None
     active_ms: single|ms|1000ms
     idle_ms: single|ms|None
-    max_events_per_second: single|int|-1
     playfield: single|machine(playfields)|playfield
     reset_when_inactive: single|bool|true
     enable_events: event_handler|event_handler:ms|None
@@ -1987,7 +1984,7 @@ sequence_shots:
     delay_switch_list: dict|machine(switches):ms|None
     delay_event_list: event_handler|event_handler:ms|None
     sequence_timeout: single|ms|0
-    playfield: single|machine(playfields)|None
+    playfield: single|machine(playfields)|playfield
 switches:
     __valid_in__: machine
     __type__: device
@@ -2000,7 +1997,6 @@ switches:
     events_when_deactivated: list|event_posted|None
     platform: single|str|None
     platform_settings: single|dict|None
-    playfield: single|machine(playfields)|playfield
     x: single|float|None
     y: single|float|None
     z: single|float|None

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/core/switch_controller.py

@@ -367,17 +367,14 @@ class SwitchController(MpfController):
         obj.state = state
         obj.last_change = timestamp
 
-        muted_state = "(muted) " if obj.is_muted else ""
         if state:
-            self.info_log("<<<<<<< '%s' active %s>>>>>>>", obj.name, muted_state)
+            self.info_log("<<<<<<< '%s' active >>>>>>>", obj.name)
         else:
-            self.info_log("<<<<<<< '%s' inactive %s>>>>>>>", obj.name, muted_state)
+            self.info_log("<<<<<<< '%s' inactive >>>>>>>", obj.name)
 
         self._cancel_timed_handlers(obj)
 
-        # Don't call switch callbacks during initialization, or devices may try and
-        # flag playfields active and mess up the ball counts.
-        if self._initialized and not obj.is_muted:
+        if not obj.is_muted:
             self._call_handlers(obj, state)
 
         for monitor in self.monitors:

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/autofire.py

@@ -34,8 +34,7 @@ class AutofireCoil(SystemWideDevice):
     collection = 'autofire_coils'
     class_label = 'autofire'
 
-    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "playfield",
-                 "_timeout_watch_time", "_timeout_max_hits",
+    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "_timeout_watch_time", "_timeout_max_hits",
                  "_timeout_disable_time", "_timeout_hits"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
@@ -45,7 +44,6 @@ class AutofireCoil(SystemWideDevice):
         super().__init__(machine, name)
         self.delay = DelayManager(self.machine)
         self._ball_search_in_progress = False
-        self.playfield = None
         self._timeout_watch_time = None
         self._timeout_max_hits = None
         self._timeout_disable_time = None
@@ -53,9 +51,8 @@ class AutofireCoil(SystemWideDevice):
 
     async def _initialize(self):
         await super()._initialize()
-        self.playfield = self.config['playfield'] or self.config['switch'].playfield
         if self.config['ball_search_order']:
-            self.playfield.ball_search.register(
+            self.config['playfield'].ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
         # pulse is handled via rule but add a handler so that we take notice anyway
         self.config['switch'].add_handler(self._hit)
@@ -64,13 +61,13 @@ class AutofireCoil(SystemWideDevice):
             self._timeout_max_hits = self.config['timeout_max_hits']
             self._timeout_disable_time = self.config['timeout_disable_time']
 
-        if f"{self.playfield.name}_active" in self.config['switch'].tags:
+        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Autofire device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
                 "redundant '{}_active' tag from that switch.".format(
-                    self.name, self.config['switch'].name, self.playfield.name,
-                    self.playfield.name), 1)
+                    self.name, self.config['switch'].name, self.config['playfield'].name,
+                    self.config['playfield'].name), 1)
 
     @event_handler(1)
     def event_enable(self, **kwargs):
@@ -172,7 +169,7 @@ class AutofireCoil(SystemWideDevice):
         if not self._enabled:
             return
         if not self._ball_search_in_progress:
-            self.playfield.mark_playfield_active_from_device_action(self.name)
+            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
         if self._timeout_watch_time:
             current_time = self.machine.clock.get_time()
             self._timeout_hits = [t for t in self._timeout_hits if t > current_time - self._timeout_watch_time / 1000.0]

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/drop_target.py

@@ -30,7 +30,7 @@ class DropTarget(SystemWideDevice):
     collection = 'drop_targets'
     class_label = 'drop_target'
 
-    __slots__ = ["reset_coil", "knockdown_coil", "banks", "complete", "delay", "playfield"]
+    __slots__ = ["reset_coil", "knockdown_coil", "banks", "_in_ball_search", "complete", "delay", "_ignore_switch_hits"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize drop target."""
@@ -39,9 +39,11 @@ class DropTarget(SystemWideDevice):
         self.banks = set()                  # type: Set[DropTargetBank]
         super().__init__(machine, name)
 
+        self._in_ball_search = False
         self.complete = False
         self.delay = DelayManager(machine)
-        self.playfield = None
+
+        self._ignore_switch_hits = False
 
     async def _initialize(self):
         await super()._initialize()
@@ -54,30 +56,29 @@ class DropTarget(SystemWideDevice):
         self.machine.events.add_handler('init_phase_4',
                                         self._register_switch_handlers, priority=1)
 
-        # If a playfield is not explicitly defined, defer to the switch's playfield
-        self.playfield = self.config['playfield'] or self.config['switch'].playfield
-
         if self.config['ball_search_order']:
-            self.playfield.ball_search.register(
+            self.config['playfield'].ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
 
-        if f"{self.playfield.name}_active" in self.config['switch'].tags:
+        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Drop target device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
                 "redundant '{}_active' tag from that switch.".format(
-                    self.name, self.config['switch'].name, self.playfield.name,
-                    self.playfield.name), 1)
+                    self.name, self.config['switch'].name, self.config['playfield'].name,
+                    self.config['playfield'].name), 1)
 
     def _ignore_switch_hits_for(self, ms, reset_attempt=None):
         """Ignore switch hits for ms."""
         self.debug_log("Ignoring switch hits for %sms", ms)
-        self.config['switch'].mute(self)
+        self.config['switch'].mute()
+        self._ignore_switch_hits = True
         self.delay.reset(name="ignore_switch", callback=self._restore_switch_hits, ms=ms, reset_attempt=reset_attempt)
 
     def _restore_switch_hits(self, reset_attempt=None):
         self.debug_log("Restoring switch hits")
-        self.config['switch'].unmute(self)
+        self.config['switch'].unmute()
+        self._ignore_switch_hits = False
         self._update_state_from_switch(reconcile=True)
 
         if self.complete and reset_attempt:
@@ -92,21 +93,24 @@ class DropTarget(SystemWideDevice):
 
     def _ball_search_phase1(self):
         if not self.complete and self.reset_coil:
-            self._ball_search_reset()
+            self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
+            self.reset_coil.pulse()
             return True
         # if down. knock down again
         if self.complete and self.knockdown_coil:
-            self._ball_search_knockdown()
+            self.knockdown_coil.pulse()
             return True
         return False
 
     def _ball_search_phase2(self):
         if self.reset_coil and self.knockdown_coil:
+            self._in_ball_search = True
             if self.complete:
-                self._ball_search_reset()
+                self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
+                self.reset_coil.pulse()
                 self.delay.add(100, self._ball_search_knockdown)
             else:
-                self._ball_search_knockdown()
+                self.knockdown_coil.pulse()
                 self.delay.add(100, self._ball_search_reset)
             return True
 
@@ -116,8 +120,10 @@ class DropTarget(SystemWideDevice):
     def _ball_search_phase3(self):
         if self.complete:
             if self.reset_coil:
-                self._ball_search_reset()
+                self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
+                self.reset_coil.pulse()
                 if self.knockdown_coil:
+                    self._in_ball_search = True
                     self.delay.add(100, self._ball_search_knockdown)
                 return True
 
@@ -125,21 +131,26 @@ class DropTarget(SystemWideDevice):
             return self._ball_search_phase1()
 
         if self.knockdown_coil:
-            self._ball_search_knockdown()
+            self.knockdown_coil.pulse()
             if self.reset_coil:
+                self._in_ball_search = True
                 self.delay.add(100, self._ball_search_reset)
             return True
 
         # fall back to phase1
         return self._ball_search_phase1()
 
+    def _ball_search_iteration_finish(self):
+        self._in_ball_search = False
+
     def _ball_search_knockdown(self):
-        self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
         self.knockdown_coil.pulse()
+        self.delay.add(100, self._ball_search_iteration_finish)
 
     def _ball_search_reset(self):
         self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
         self.reset_coil.pulse()
+        self.delay.add(100, self._ball_search_iteration_finish)
 
     def _ball_search(self, phase, iteration):
         del iteration
@@ -209,9 +220,13 @@ class DropTarget(SystemWideDevice):
 
         self.debug_log("Drop target %s switch %s has active value %s compared to drop complete %s",
                        self.name, self.config['switch'].name, is_complete, self.complete)
+        if self._in_ball_search or self._ignore_switch_hits:
+            self.debug_log("Ignoring state change in drop target %s due to being in ball search "
+                           "or ignoring switch hits", self.name)
+            return
 
         if not reconcile:
-            self.playfield.mark_playfield_active_from_device_action(self.name)
+            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
 
         if is_complete != self.complete:
 
@@ -220,7 +235,7 @@ class DropTarget(SystemWideDevice):
             else:
                 self._up()
 
-            self._update_banks(reconcile)
+            self._update_banks()
 
     def _down(self):
         self.complete = True
@@ -235,9 +250,9 @@ class DropTarget(SystemWideDevice):
         '''event: drop_target_(name)_up
         desc: The drop target (name) has just changed to the "up" state.'''
 
-    def _update_banks(self, reconcile=False):
+    def _update_banks(self):
         for bank in self.banks:
-            bank.member_target_change(reconcile)
+            bank.member_target_change()
 
     def add_to_bank(self, bank):
         """Add this drop target to a drop target bank.
@@ -325,6 +340,7 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         self.down = 0
         self.up = 0
         self.delay = DelayManager(machine)
+        self._ignore_switch_hits = False
 
     @property
     def can_exist_outside_of_game(self):
@@ -337,12 +353,6 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         self.reset_coil = self.config['reset_coil']
         self.reset_coils = self.config['reset_coils']
 
-        # If individual drop targets have reset coils, they will ball search themselves.
-        # The bank will only trigger in ball search if it has its own bank coils defined
-        if self.config['ball_search_order'] and (self.config['reset_coil'] or self.config['reset_coils']):
-            self.config['playfield'].ball_search.register(
-                self.config['ball_search_order'], self._ball_search, self.name)
-
     def device_loaded_in_mode(self, mode: Mode, player: Player):
         """Add targets."""
         self._add_targets_to_bank()
@@ -356,9 +366,6 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         """Add targets to bank."""
         for target in self.drop_targets:
             target.add_to_bank(self)
-            assert self.config['playfield'] == target.playfield, \
-                   f"Drop target bank has a playfield {self.config['playfield']} but target {target.name} " \
-                   f"has playfield {target.playfield}. Banks do not support targets on multiple playfields."
 
         self.member_target_change()
 
@@ -398,7 +405,7 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
 
             # Mute all the bank's switches
             if self.config['ignore_switch_ms']:
-                drop_target.config['switch'].mute(self)
+                drop_target.config['switch'].mute()
 
         for coil in self.reset_coils:
             coils.add(coil)
@@ -416,23 +423,23 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
 
         # Set a delay to unmute all the switches after the combined reset time plus ignore
         if self.config['ignore_switch_ms']:
-            self.debug_log("Switches ignored, setting %sms timer to restore them.", self.config['ignore_switch_ms'])
             restore_delay_ms += self.config['ignore_switch_ms']
             if self.config['max_reset_attempts'] and attempt is None:
                 attempt = 1
+            self._ignore_switch_hits = True
             self.delay.add(ms=restore_delay_ms,
                            callback=self._restore_switch_hits,
                            name='ignore_hits',
                            reset_attempt=attempt)
 
     def _restore_switch_hits(self, reset_attempt=None):
-        self.debug_log("Restoring switch hits")
         for target in self.drop_targets:
-            target.config['switch'].unmute(self)
+            target.config['switch'].unmute()
             target.external_reset_from_bank()
+        self._ignore_switch_hits = False
         self.member_target_change()
 
-        if self.down != 0 and reset_attempt is not None and self.config['max_reset_attempts'] is not None:
+        if self.down != 0 and reset_attempt is not None:
             if reset_attempt < self.config['max_reset_attempts']:
                 self.debug_log("Reset failed after attempt %s, trying again.", reset_attempt)
                 reset_attempt += 1
@@ -442,16 +449,15 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         else:
             self.debug_log("Reset confirmed!")
 
-    def _ball_search(self, phase, iteration):
-        attempt = (iteration - 1) * phase + iteration
-        self.reset(attempt)
-
-    def member_target_change(self, reconcile=False):
+    def member_target_change(self):
         """Handle that a member drop target has changed state.
 
         This method causes this group to update its down and up counts and
         complete status.
         """
+        if self._ignore_switch_hits:
+            return
+
         self.down = 0
         self.up = 0
 
@@ -463,13 +469,8 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
 
         self.debug_log(
             'Member drop target status change: Up: %s, Down: %s,'
-            ' Total: %s, Reconcile: %s', self.up, self.down,
-            len(self.drop_targets), reconcile)
-
-        # Don't change the internal state during reconciliation. After the reset
-        # is complete the bank will re-check and post the final state.
-        if reconcile:
-            return
+            ' Total: %s', self.up, self.down,
+            len(self.drop_targets))
 
         if self.down == len(self.drop_targets):
             self._bank_down()
@@ -501,7 +502,6 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         self.state = DropTargetBankState.UP
         self.complete = False
         self.debug_log('All targets are up')
-
         self.machine.events.post('drop_target_bank_' + self.name + '_up')
         '''event: drop_target_bank_(name)_up
         desc: Every drop target in the drop target bank called
@@ -512,7 +512,6 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         prev_state = self.state
         self.state = DropTargetBankState.MIXED
         self.complete = False
-
         self.machine.events.post('drop_target_bank_' + self.name + '_mixed',
                                  prev_value=prev_state,
                                  down=self.down)

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/magnet.py

@@ -14,7 +14,7 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     """Controls a playfield magnet in a pinball machine."""
 
-    __slots__ = ["delay", "_active", "_release_in_progress", "playfield"]
+    __slots__ = ["delay", "_active", "_release_in_progress"]
 
     config_section = 'magnets'
     collection = 'magnets'
@@ -24,7 +24,6 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         """Initialize magnet."""
         super().__init__(machine, name)
         self.delay = DelayManager(machine)
-        self.playfield = None
         self._active = False
         self._release_in_progress = False
 
@@ -34,9 +33,6 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
         if self.config['grab_switch']:
             self.config['grab_switch'].add_handler(self.grab_ball)
-            self.playfield = self.config['playfield'] or self.config['grab_switch'].playfield
-        else:
-            self.playfield = self.config['playfield']
 
     def _disable(self):
         """Disable magnet."""
@@ -65,8 +61,8 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     def grab_ball(self):
         """Grab a ball."""
-        if self.playfield:
-            self.playfield.mark_playfield_active_from_device_action(self.name)
+        # mark the playfield active no matter what
+        self.config['playfield'].mark_playfield_active_from_device_action(self.name)
         # check if magnet is enabled or already active
         if not self.enabled or self._active or self._release_in_progress:
             return

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/sequence_shot.py

@@ -100,7 +100,7 @@ class SequenceShot(SystemWideDevice, ModeDevice):
         # switch is starting a new sequence or continuing an existing one
         del kwargs
 
-        # mark playfield active if a playfield is defined for this sequence
+        # mark playfield active
         if self.config['playfield']:
             self.config['playfield'].mark_playfield_active_from_device_action(self.name)
 

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/shot.py

@@ -24,8 +24,8 @@ class Shot(EnableDisableMixin, ModeDevice):
     to track shots.
     """
 
-    __slots__ = ["delay", "active_sequences", "active_delays", "playfield", "running_show",
-                 "_handlers", "_player_var_name"]
+    __slots__ = ["delay", "active_sequences", "active_delays", "running_show", "_handlers",
+                 "_player_var_name"]
 
     def __init__(self, machine, name):
         """Initialize shot."""
@@ -40,29 +40,22 @@ class Shot(EnableDisableMixin, ModeDevice):
         """List of tuples: (id, current_position_index, next_switch)"""
         self.active_delays = set()
         self.running_show = None
-        self.playfield = None
         self._handlers = []
 
     async def _initialize(self) -> None:
         """Register playfield active handlers."""
         await super()._initialize()
 
-        self._register_control_event_handlers()
-
-        # No need to mark active if not required
-        if not self.config['mark_playfield_active']:
-            return
-
         for switch in self.config['switches'] + list(self.config['delay_switch'].keys()):
             # mark the playfield active no matter what
-            switch.add_handler(self._mark_active,
-                               callback_kwargs={'playfield': switch.config['playfield']})
+            switch.add_handler(self._mark_active)
+        self._register_control_event_handlers()
 
-    def _mark_active(self, playfield, **kwargs):
+    def _mark_active(self, **kwargs):
         """Mark playfield active."""
         del kwargs
-        # Whatever playfield the triggering switch is on, mark *that* as active
-        playfield.mark_playfield_active_from_device_action(self.name)
+        if self.config['mark_playfield_active']:
+            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
 
     def device_loaded_in_mode(self, mode: Mode, player: Player):
         """Add device to a mode that was already started.

{mpf-0.57.2 → mpf-0.57.2.dev2}/mpf/devices/spinner.py

@@ -22,7 +22,7 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
     collection = 'spinners'
     class_label = 'spinner'
 
-    __slots__ = ["hits", "_active_ms", "_active", "_idle", "_event_buffer_ms", "delay"]
+    __slots__ = ["hits", "_active_ms", "_active", "_idle", "delay"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize spinner device."""
@@ -30,21 +30,15 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         self._active = False
         self._idle = True
         self._active_ms = None
-        self._event_buffer_ms = None
         self.hits = None
         self.delay = DelayManager(machine)
         self.enabled = True  # Default to enabled
 
-        self.configure_logging(f'Spinner.{name}')
-
     async def _initialize(self):
         await super()._initialize()
         self.hits = 0
         # Cache this value because it's used a lot in rapid succession
         self._active_ms = self.config['active_ms']
-        if self.config['max_events_per_second'] > 0:
-            self._event_buffer_ms = (1 / self.config['max_events_per_second']) * 1000
-            self.log.debug("Configured event buffer for %s", self._event_buffer_ms)
         # Can't read the switch until the switch controller is set up
         self.machine.events.add_handler('init_phase_4',
                                         self._register_switch_handlers, priority=1)
@@ -86,21 +80,7 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
             self._active = True
             self._idle = False
         self.hits += 1
-
-        if not self._event_buffer_ms or not self.delay.check("event_buffer"):
-            self._post_hit_event(label=label, last_hits=self.hits - 1)
-
-    def _post_hit_event(self, **kwargs):
-        last_hits = kwargs.get("last_hits", 0)
-        self.log.debug("Buffer check has %s previous hits, current is %s", last_hits, self.hits)
-        if last_hits and last_hits == self.hits:
-            self.delay.remove("event_buffer")
-            return
-
-        label = kwargs.get("label")
-
-        self.machine.events.post("spinner_{}_hit".format(self.name), hits=self.hits,
-                                 change=self.hits - last_hits, label=label)
+        self.machine.events.post("spinner_{}_hit".format(self.name), hits=self.hits, label=label)
         '''event: spinner_(name)_hit
         desc: The spinner (name) was just hit.
 
@@ -111,19 +91,15 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         label: The label of the switch that was hit
         '''
         if label:
-            self.machine.events.post("spinner_{}_{}_hit".format(self.name, label),
-                                     hits=self.hits, change=self.hits - last_hits)
+            self.machine.events.post("spinner_{}_{}_hit".format(self.name, label))
             '''event: spinner_(name)_(label)_hit
             desc: The spinner (name) was just hit on the switch labelled (label).
 
             This event will post whenever a spinner switch is hit and labels
             are defined for the spinner
             '''
-        self.delay.reset(self._active_ms, self._deactivate, "deactivate")
-
-        if self._event_buffer_ms:
-            self.delay.add(self._event_buffer_ms, self._post_hit_event, "event_buffer",
-                           label=label, last_hits=self.hits)
+        self.delay.clear()
+        self.delay.add(self._active_ms, self._deactivate)
 
     def _deactivate(self, **kwargs):
         """Post an 'inactive' event after no switch hits for the active_ms duration."""
@@ -140,7 +116,7 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         '''
         self._active = False
         if self.config['idle_ms']:
-            self.delay.reset(self.config['idle_ms'], self._on_idle, "idle")
+            self.delay.add(self.config['idle_ms'], self._on_idle)
             if self.config['reset_when_inactive']:
                 self.hits = 0
         else: