mpf 0.80.0.dev2__tar.gz → 0.80.0.dev3__tar.gz

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/PKG-INFO

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

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/mpf/_version.py

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

mpf-0.80.0.dev3/mpf/config_players/bus_player.py

@@ -0,0 +1,36 @@
+"""Bus player plugin for MPF to support GMC."""
+
+from functools import partial
+from mpf.config_players.plugin_player import PluginPlayer
+
+
+class BusPlayer(PluginPlayer):
+
+    """Base class for part of the bus player which runs as part of MPF.
+
+    Note: This class is loaded by MPF and everything in it is in the context of
+    MPF, not the mc.
+    """
+
+    config_file_section = 'bus_player'
+    show_section = 'buses'
+
+    def _validate_config_item(self, device, device_settings):
+        # device is bus name, device_settings is configuration
+
+        device_settings = self.machine.config_validator.validate_config(
+            'bus_player', device_settings)
+
+        return_dict = dict()
+        return_dict[device] = device_settings
+
+        return return_dict
+
+    def _register_trigger(self, event, **kwargs):
+        """Register trigger via BCP for MC."""
+        del kwargs
+        client = self.machine.bcp.transport.get_named_client("local_display")
+        if client:
+            self.machine.bcp.interface.add_registered_trigger_event_for_client(client, event)
+        else:
+            self.machine.events.add_handler("bcp_clients_connected", partial(self._register_trigger, event))

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/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)|playfield
+    playfield: single|machine(playfields)|None
     timeout_watch_time: single|ms|0
     timeout_max_hits: single|int|0
     timeout_disable_time: single|ms|0
@@ -302,6 +302,11 @@ bonus_entries:
     player_score_entry: single|str|None
     skip_if_zero: single|bool|true
     skip_if_negative: single|bool|false
+bus_player:
+    __valid_in__: machine, mode, show
+    __type__: config_player
+    action: single|enum(pause,stop,unpause)|
+    fade: single|secs|0.1sec
 coils:
     __valid_in__: machine
     __type__: device
@@ -494,11 +499,12 @@ 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)|playfield
+    playfield: single|machine(playfields)|None
 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,6 +512,7 @@ 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|
@@ -1075,7 +1082,7 @@ magnets:
     release_time: single|ms|500ms
     fling_drop_time: single|ms|250ms
     fling_regrab_time: single|ms|50ms
-    playfield: single|machine(playfields)|playfield
+    playfield: single|machine(playfields)|None
     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
@@ -1301,7 +1308,7 @@ player_vars:
 playfields:
     __valid_in__: machine
     __type__: device
-    enable_ball_search: single|bool|None
+    enable_ball_search: single|template_bool|None
     ball_search_timeout: single|ms|15s
     ball_search_interval: single|ms|150ms
     ball_search_phase_1_searches: single|int|3
@@ -1767,6 +1774,7 @@ 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
@@ -1823,7 +1831,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)|playfield
+    playfield: single|machine(playfields)|None
 switches:
     __valid_in__: machine
     __type__: device
@@ -1831,10 +1839,12 @@ switches:
     type: single|enum(NC,NO)|NO
     debounce: single|enum(auto,quick,normal)|auto
     ignore_window_ms: single|ms|0
+    ignore_during_ball_search: single|bool|false
     events_when_activated: list|event_posted|None
     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.80.0.dev2 → mpf-0.80.0.dev3}/mpf/core/ball_search.py

@@ -121,13 +121,16 @@ class BallSearch(MpfController):
             return
 
         del kwargs
-        if self.playfield.config['enable_ball_search'] is False or (
-            not self.playfield.config['enable_ball_search'] and
+        is_ball_search_enabled = self.playfield.config['enable_ball_search'].evaluate({}) if \
+            self.playfield.config['enable_ball_search'] else None
+        if is_ball_search_enabled is False or (
+            is_ball_search_enabled is None and
                 not self.machine.config['mpf']['default_ball_search']):
             return
 
         if not self.callbacks:
-            raise AssertionError("No callbacks registered")
+            raise AssertionError(f"Cannot run ball search on playfield '{self.playfield.name}', no callbacks "
+                                 "registered. Do you have any shots/devices defined in this playfield?")
 
         self.debug_log("Enabling Ball Search")
 
@@ -255,14 +258,6 @@ class BallSearch(MpfController):
                 element = next(self.iterator)
             except StopIteration:
                 self.iteration += 1
-                self.machine.events.post('ball_search_phase_{}'.format(self.phase),
-                                         iteration=self.iteration)
-                '''event: ball_search_phase_(num)
-
-                desc: The ball search phase (num) has started.
-                args:
-                    iteration: Current iteration of phase (num)
-                '''
                 # give up at some point
                 if self.iteration > self.playfield.config[
                         'ball_search_phase_{}_searches'.format(self.phase)]:
@@ -272,6 +267,15 @@ class BallSearch(MpfController):
                         self.give_up()
                         return
 
+                self.machine.events.post('ball_search_phase_{}'.format(self.phase),
+                                         iteration=self.iteration)
+                '''event: ball_search_phase_(num)
+
+                desc: The ball search phase (num) has started.
+                args:
+                    iteration: Current iteration of phase (num)
+                '''
+
                 self.iterator = iter(self.callbacks)
                 element = next(self.iterator)
                 timeout = self.playfield.config[

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/mpf/core/switch_controller.py

@@ -367,14 +367,18 @@ 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 >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' active %s>>>>>>>", obj.name, muted_state)
         else:
-            self.info_log("<<<<<<< '%s' inactive >>>>>>>", obj.name)
+            self.info_log("<<<<<<< '%s' inactive %s>>>>>>>", obj.name, muted_state)
 
         self._cancel_timed_handlers(obj)
 
-        self._call_handlers(obj, state)
+        # 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:
+            self._call_handlers(obj, state)
 
         for monitor in self.monitors:
             monitor(MonitoredSwitchChange(name=obj.name, label=obj.label, platform=obj.platform,

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/mpf/devices/autofire.py

@@ -34,7 +34,8 @@ class AutofireCoil(SystemWideDevice):
     collection = 'autofire_coils'
     class_label = 'autofire'
 
-    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "_timeout_watch_time", "_timeout_max_hits",
+    __slots__ = ["_enabled", "_rule", "delay", "_ball_search_in_progress", "playfield",
+                 "_timeout_watch_time", "_timeout_max_hits",
                  "_timeout_disable_time", "_timeout_hits"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
@@ -44,6 +45,7 @@ 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
@@ -51,8 +53,9 @@ 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.config['playfield'].ball_search.register(
+            self.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)
@@ -61,13 +64,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.config['playfield'].name}_active" in self.config['switch'].tags:
+        if f"{self.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.config['playfield'].name,
-                    self.config['playfield'].name), 1)
+                    self.name, self.config['switch'].name, self.playfield.name,
+                    self.playfield.name), 1)
 
     @event_handler(1)
     def event_enable(self, **kwargs):
@@ -169,7 +172,7 @@ class AutofireCoil(SystemWideDevice):
         if not self._enabled:
             return
         if not self._ball_search_in_progress:
-            self.config['playfield'].mark_playfield_active_from_device_action()
+            self.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.80.0.dev2 → mpf-0.80.0.dev3}/mpf/devices/diverter.py

@@ -379,15 +379,15 @@ class Diverter(SystemWideDevice):
         del phase
         del iteration
         if self.active:
-            self.info_log("Temporarily deactivating diverter to search ball for %sms",
-                          self.config['ball_search_hold_time'])
+            self.debug_log("Temporarily deactivating diverter to search ball for %sms",
+                           self.config['ball_search_hold_time'])
             self._coil_deactivate()
             self.machine.delay.add(self.config['ball_search_hold_time'],
                                    self._coil_activate,
                                    'diverter_{}_ball_search'.format(self.name))
         else:
-            self.info_log("Temporarily activating diverter to search ball for %sms",
-                          self.config['ball_search_hold_time'])
+            self.debug_log("Temporarily activating diverter to search ball for %sms",
+                           self.config['ball_search_hold_time'])
             self._coil_activate()
             self.machine.delay.add(self.config['ball_search_hold_time'],
                                    self._coil_deactivate,

{mpf-0.80.0.dev2 → mpf-0.80.0.dev3}/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", "_in_ball_search", "complete", "delay", "_ignore_switch_hits"]
+    __slots__ = ["reset_coil", "knockdown_coil", "banks", "complete", "delay", "playfield"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize drop target."""
@@ -39,11 +39,9 @@ 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._ignore_switch_hits = False
+        self.playfield = None
 
     async def _initialize(self):
         await super()._initialize()
@@ -56,25 +54,30 @@ 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.config['playfield'].ball_search.register(
+            self.playfield.ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
 
-        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
+        if f"{self.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.config['playfield'].name,
-                    self.config['playfield'].name), 1)
+                    self.name, self.config['switch'].name, self.playfield.name,
+                    self.playfield.name), 1)
 
     def _ignore_switch_hits_for(self, ms, reset_attempt=None):
         """Ignore switch hits for ms."""
-        self._ignore_switch_hits = True
+        self.debug_log("Ignoring switch hits for %sms", ms)
+        self.config['switch'].mute()
         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._ignore_switch_hits = False
+        self.debug_log("Restoring switch hits")
+        self.config['switch'].unmute()
         self._update_state_from_switch(reconcile=True)
 
         if self.complete and reset_attempt:
@@ -89,24 +92,21 @@ class DropTarget(SystemWideDevice):
 
     def _ball_search_phase1(self):
         if not self.complete and self.reset_coil:
-            self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
-            self.reset_coil.pulse()
+            self._ball_search_reset()
             return True
         # if down. knock down again
         if self.complete and self.knockdown_coil:
-            self.knockdown_coil.pulse()
+            self._ball_search_knockdown()
             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._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
-                self.reset_coil.pulse()
+                self._ball_search_reset()
                 self.delay.add(100, self._ball_search_knockdown)
             else:
-                self.knockdown_coil.pulse()
+                self._ball_search_knockdown()
                 self.delay.add(100, self._ball_search_reset)
             return True
 
@@ -116,10 +116,8 @@ class DropTarget(SystemWideDevice):
     def _ball_search_phase3(self):
         if self.complete:
             if self.reset_coil:
-                self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
-                self.reset_coil.pulse()
+                self._ball_search_reset()
                 if self.knockdown_coil:
-                    self._in_ball_search = True
                     self.delay.add(100, self._ball_search_knockdown)
                 return True
 
@@ -127,26 +125,21 @@ class DropTarget(SystemWideDevice):
             return self._ball_search_phase1()
 
         if self.knockdown_coil:
-            self.knockdown_coil.pulse()
+            self._ball_search_knockdown()
             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
@@ -216,13 +209,9 @@ 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.config['playfield'].mark_playfield_active_from_device_action()
+            self.playfield.mark_playfield_active_from_device_action(self.name)
 
         if is_complete != self.complete:
 
@@ -231,7 +220,7 @@ class DropTarget(SystemWideDevice):
             else:
                 self._up()
 
-            self._update_banks()
+            self._update_banks(reconcile)
 
     def _down(self):
         self.complete = True
@@ -246,9 +235,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):
+    def _update_banks(self, reconcile=False):
         for bank in self.banks:
-            bank.member_target_change()
+            bank.member_target_change(reconcile)
 
     def add_to_bank(self, bank):
         """Add this drop target to a drop target bank.
@@ -269,8 +258,7 @@ class DropTarget(SystemWideDevice):
         device.
         Make sure we do not mark the playfield as active.
         """
-        if self.machine.switch_controller.is_active(self.config['switch']):
-            self._ignore_switch_hits_for(ms=self.config['ignore_switch_ms'])
+        self._update_state_from_switch(reconcile=True)
 
     def remove_from_bank(self, bank):
         """Remove the DropTarget from a bank.
@@ -337,7 +325,6 @@ 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):
@@ -350,6 +337,12 @@ 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()
@@ -363,6 +356,9 @@ 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} " \
+                   "has playfield {target.playfield}. Banks do not support targets on multiple playfields."
 
         self.member_target_change()
 
@@ -400,8 +396,9 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
             if drop_target.reset_coil and drop_target.complete:
                 coils.add(drop_target.reset_coil)
 
-            # tell the drop target that we are going to reset it physically
-            drop_target.external_reset_from_bank()
+            # Mute all the bank's switches
+            if self.config['ignore_switch_ms']:
+                drop_target.config['switch'].mute()
 
         for coil in self.reset_coils:
             coils.add(coil)
@@ -417,21 +414,25 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
             self.debug_log("Coil %s firing has a wait of %s!", coil, wait_ms)
             restore_delay_ms += wait_ms
 
+        # 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._ignore_switch_hits = False
+        self.debug_log("Restoring switch hits")
+        for target in self.drop_targets:
+            target.config['switch'].unmute()
+            target.external_reset_from_bank()
         self.member_target_change()
 
-        if self.down != 0 and reset_attempt is not None:
+        if self.down != 0 and reset_attempt is not None and self.config['max_reset_attempts'] 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
@@ -441,15 +442,16 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
         else:
             self.debug_log("Reset confirmed!")
 
-    def member_target_change(self):
+    def _ball_search(self, phase, iteration):
+        attempt = (iteration - 1) * phase + iteration
+        self.reset(attempt)
+
+    def member_target_change(self, reconcile=False):
         """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
 
@@ -461,8 +463,13 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
 
         self.debug_log(
             'Member drop target status change: Up: %s, Down: %s,'
-            ' Total: %s', self.up, self.down,
-            len(self.drop_targets))
+            ' 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
 
         if self.down == len(self.drop_targets):
             self._bank_down()
@@ -494,6 +501,7 @@ 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
@@ -504,6 +512,7 @@ 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.80.0.dev2 → mpf-0.80.0.dev3}/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"]
+    __slots__ = ["delay", "_active", "_release_in_progress", "playfield"]
 
     config_section = 'magnets'
     collection = 'magnets'
@@ -24,6 +24,7 @@ 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
 
@@ -33,6 +34,9 @@ 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."""
@@ -61,8 +65,8 @@ class Magnet(EnableDisableMixinSystemWideDevice, SystemWideDevice):
 
     def grab_ball(self):
         """Grab a ball."""
-        # mark the playfield active no matter what
-        self.config['playfield'].mark_playfield_active_from_device_action()
+        if self.playfield:
+            self.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.80.0.dev2 → mpf-0.80.0.dev3}/mpf/devices/playfield.py

@@ -261,19 +261,19 @@ class Playfield(SystemWideDevice):
             incoming_ball.ball_arrived()
             break
 
-    def _mark_playfield_active(self):
+    def _mark_playfield_active(self, source=None):
         self.ball_arrived()
-        self.machine.events.post_boolean(self.name + "_active")
+        self.machine.events.post_boolean(self.name + "_active", source=source)
         '''event: (name)_active
         desc: The playfield called (name) is now active, meaning there's
         at least one loose ball on it.
         '''
 
-    def mark_playfield_active_from_device_action(self):
+    def mark_playfield_active_from_device_action(self, device_name=None):
         """Mark playfield active because a device on the playfield detected activity."""
-        self._playfield_switch_hit()
+        self._playfield_switch_hit(source=device_name)
 
-    def _playfield_switch_hit(self, **kwargs):
+    def _playfield_switch_hit(self, source=None, **kwargs):
         """Playfield switch was hit.
 
         A switch tagged with '<this playfield name>_active' was just hit,
@@ -281,7 +281,7 @@ class Playfield(SystemWideDevice):
 
         """
         if self.balls <= 0 or (kwargs.get('balls') and self.balls - kwargs['balls'] < 0):
-            self._mark_playfield_active()
+            self._mark_playfield_active(source)
 
             if not self.num_balls_requested:
                 self.debug_log("Playfield was activated with no balls expected.")