mpf 0.57.2.dev2__tar.gz → 0.57.2.dev4__tar.gz

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

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

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

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

{mpf-0.57.2.dev2 → mpf-0.57.2.dev4}/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
@@ -493,11 +493,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
@@ -505,6 +506,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|
@@ -1074,7 +1076,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
@@ -1984,7 +1986,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
@@ -1997,6 +1999,7 @@ 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.dev2 → mpf-0.57.2.dev4}/mpf/core/switch_controller.py

@@ -367,14 +367,17 @@ 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)
 
-        if not obj.is_muted:
+        # 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:

{mpf-0.57.2.dev2 → mpf-0.57.2.dev4}/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.name)
+            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.57.2.dev2 → mpf-0.57.2.dev4}/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,29 +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.debug_log("Ignoring switch hits for %sms", ms)
         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._ignore_switch_hits = False
         self._update_state_from_switch(reconcile=True)
 
         if self.complete and reset_attempt:
@@ -93,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
 
@@ -120,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
 
@@ -131,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
@@ -220,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.name)
+            self.playfield.mark_playfield_active_from_device_action(self.name)
 
         if is_complete != self.complete:
 
@@ -235,7 +220,7 @@ class DropTarget(SystemWideDevice):
             else:
                 self._up()
 
-            self._update_banks()
+            self._update_banks(reconcile)
 
     def _down(self):
         self.complete = True
@@ -250,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.
@@ -340,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):
@@ -353,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()
@@ -366,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()
 
@@ -423,20 +416,20 @@ 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()
             target.external_reset_from_bank()
-        self._ignore_switch_hits = False
         self.member_target_change()
 
         if self.down != 0 and reset_attempt is not None:
@@ -449,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
 
@@ -469,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()
@@ -502,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
@@ -512,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.57.2.dev2 → mpf-0.57.2.dev4}/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(self.name)
+        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.57.2.dev2 → mpf-0.57.2.dev4}/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
+        # mark playfield active if a playfield is defined for this sequence
         if self.config['playfield']:
             self.config['playfield'].mark_playfield_active_from_device_action(self.name)
 

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

@@ -24,8 +24,8 @@ class Shot(EnableDisableMixin, ModeDevice):
     to track shots.
     """
 
-    __slots__ = ["delay", "active_sequences", "active_delays", "running_show", "_handlers",
-                 "_player_var_name"]
+    __slots__ = ["delay", "active_sequences", "active_delays", "playfield", "running_show",
+                 "_handlers", "_player_var_name"]
 
     def __init__(self, machine, name):
         """Initialize shot."""
@@ -40,22 +40,29 @@ 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)
-        self._register_control_event_handlers()
+            switch.add_handler(self._mark_active,
+                               callback_kwargs={'playfield': switch.config['playfield']})
 
-    def _mark_active(self, **kwargs):
+    def _mark_active(self, playfield, **kwargs):
         """Mark playfield active."""
         del kwargs
-        if self.config['mark_playfield_active']:
-            self.config['playfield'].mark_playfield_active_from_device_action(self.name)
+        # Whatever playfield the triggering switch is on, mark *that* as active
+        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.dev2 → mpf-0.57.2.dev4}/mpf/devices/switch.py

@@ -266,3 +266,8 @@ class Switch(SystemWideDevice, DevicePositionMixin):
     def is_muted(self):
         """True if this switch is currently muted."""
         return self._mutes > 0
+
+    @property
+    def playfield(self):
+        """Return the playfield this switch is assigned to."""
+        return self.config['playfield']

{mpf-0.57.2.dev2 → mpf-0.57.2.dev4}/mpf/platforms/opp/opp.py

@@ -462,6 +462,8 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             if msg[2 + wing_index] == ord(OppRs232Intf.WING_SOL):
                 sol_mask |= (0x0f << (4 * wing_index))
                 inp_mask |= (0x0f << (8 * wing_index))
+            if msg[2 + wing_index] == ord(OppRs232Intf.WING_SOL_8):
+                sol_mask |= (0xff << (8 * wing_index))
             elif msg[2 + wing_index] == ord(OppRs232Intf.WING_INP):
                 inp_mask |= (0xff << (8 * wing_index))
             elif msg[2 + wing_index] == ord(OppRs232Intf.WING_INCAND):

{mpf-0.57.2.dev2 → mpf-0.57.2.dev4}/mpf/platforms/opp/opp_rs232_intf.py

@@ -54,6 +54,7 @@ class OppRs232Intf:
     WING_SW_MATRIX_OUT_LOW_WING = b'\x0a'
     WING_LAMP_MATRIX_COL_WING = b'\x0b'
     WING_LAMP_MATRIX_ROW_WING = b'\x0c'
+    WING_SOL_8 = b'\x0d'
 
     NUM_G2_INP_PER_BRD = 32
     CFG_INP_STATE = b'\x00'