mpf 0.57.2.dev3__tar.gz → 0.57.2.dev5__tar.gz

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/PKG-INFO

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

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/_version.py

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

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/assets/show.py

@@ -521,6 +521,7 @@ class RunningShow:
     def _start_play(self):
         if self._stopped:
             return
+        self.machine.show_controller.info_log("Starting show %s", self.show.name)
 
         self._total_steps = len(self.show_steps)
 
@@ -560,6 +561,7 @@ class RunningShow:
         """Stop show."""
         if self._stopped:
             return
+        self.machine.show_controller.info_log("Stopping show %s", self.show.name)
 
         self._stopped = True
 
@@ -589,12 +591,14 @@ class RunningShow:
 
     def pause(self):
         """Pause show."""
+        self.machine.show_controller.info_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.info_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.dev3 → mpf-0.57.2.dev5}/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,7 +493,7 @@ 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
@@ -1076,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
@@ -1930,6 +1930,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
@@ -1986,7 +1987,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
@@ -1999,6 +2000,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.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/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"]
+    __slots__ = ["reset_coil", "knockdown_coil", "banks", "complete", "delay", "playfield"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize drop target."""
@@ -41,6 +41,7 @@ class DropTarget(SystemWideDevice):
 
         self.complete = False
         self.delay = DelayManager(machine)
+        self.playfield = None
 
     async def _initialize(self):
         await super()._initialize()
@@ -53,17 +54,20 @@ 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."""
@@ -207,7 +211,7 @@ class DropTarget(SystemWideDevice):
                        self.name, self.config['switch'].name, is_complete, self.complete)
 
         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:
 
@@ -352,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()
 
@@ -425,7 +432,7 @@ class DropTargetBank(SystemWideDevice, ModeDevice):
             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

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/mpf/devices/spinner.py

@@ -22,7 +22,7 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
     collection = 'spinners'
     class_label = 'spinner'
 
-    __slots__ = ["hits", "_active_ms", "_active", "_idle", "delay"]
+    __slots__ = ["hits", "_active_ms", "_active", "_idle", "_event_buffer_ms", "delay"]
 
     def __init__(self, machine: "MachineController", name: str) -> None:
         """Initialize spinner device."""
@@ -30,15 +30,21 @@ 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)
@@ -80,7 +86,21 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
             self._active = True
             self._idle = False
         self.hits += 1
-        self.machine.events.post("spinner_{}_hit".format(self.name), hits=self.hits, label=label)
+
+        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)
         '''event: spinner_(name)_hit
         desc: The spinner (name) was just hit.
 
@@ -91,15 +111,19 @@ 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))
+            self.machine.events.post("spinner_{}_{}_hit".format(self.name, label),
+                                     hits=self.hits, change=self.hits - last_hits)
             '''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.clear()
-        self.delay.add(self._active_ms, self._deactivate)
+        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)
 
     def _deactivate(self, **kwargs):
         """Post an 'inactive' event after no switch hits for the active_ms duration."""
@@ -116,7 +140,7 @@ class Spinner(EnableDisableMixinSystemWideDevice, SystemWideDevice):
         '''
         self._active = False
         if self.config['idle_ms']:
-            self.delay.add(self.config['idle_ms'], self._on_idle)
+            self.delay.reset(self.config['idle_ms'], self._on_idle, "idle")
             if self.config['reset_when_inactive']:
                 self.hits = 0
         else:

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/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.dev3 → mpf-0.57.2.dev5}/mpf/platforms/fast/fast.py

@@ -512,6 +512,7 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
 
         return switch
 
+    # pylint: disable-msg=too-many-locals
     def configure_light(self, number, subtype, config, platform_settings) -> LightPlatformInterface:
         """Configure light in platform."""
         del platform_settings
@@ -567,7 +568,10 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
 
             elif int(parts[0]) > 255:
                 # EXP LED in int form, which is how "previous:" values are calculated
-                this_led_number = hex(int(parts[0]))[2:]
+
+                raw_hex_string = hex(int(parts[0]))[2:]  # lowercase with 0x prefix stripped"
+                this_led_number = Util.normalize_hex_string(raw_hex_string, len(raw_hex_string))
+
                 exp_board = self.exp_boards_by_address[this_led_number[:2]]
 
                 if this_led_number not in self.fast_exp_leds:
@@ -676,13 +680,14 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
                 if 0 <= channel <= 2:
                     result = []
                     for i in range(3):
+                        working_parts = parts.copy()
                         if i + channel > 2:
                             # Channel rolls over, increment the LED number
-                            parts[3] = str(int(parts[3]) + 1)
-                            parts[4] = '0'
+                            working_parts[3] = str(int(working_parts[3]) + 1)
+                            working_parts[4] = str((channel + i) % 3)
                         else:
-                            parts[4] = str(channel + i)
-                        result.append({'number': '-'.join(parts)})
+                            working_parts[4] = str(channel + i)
+                        result.append({'number': '-'.join(working_parts)})
                     return result
                 raise AssertionError(f"Invalid LED channel: {channel}")
             raise AssertionError(f"Invalid LED number: {number}")

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/tests/machine_files/fast/config/exp.yaml

@@ -63,11 +63,11 @@ lights:
   led3:
     number: brian-1-3
   led4:
-    number: brian-b1-2-1
+    number: brian-b1-2-1-0
   led5:
-    number: brian-b1-2-2
+    number: brian-b1-2-2-1
   led6:
-    number: aaron-b2-1-1
+    number: aaron-b2-1-1-2
   led7:
     number: aaron-1-1
   led8:
@@ -120,7 +120,7 @@ lights:
     start_channel: brian-b2-2-3-0  #88222-0, 88222-1, 88222-2, 88223-0
     type: rgbw
   led29:
-    channels:  # testing out of order, non-contiquous channels
+    channels:  # testing out of order, non-contiguous channels
       red:
         number: neuron-1-10-0  # 48009-0
       green:
@@ -130,6 +130,13 @@ lights:
       white:
         number: neuron-1-11-2  # 4800A-2
 
+  led30:
+    number: dave-4-12
+    type: rgb
+  led31:
+    previous: led30
+    type: rgb
+
 servos:
     servo1:
         number: dAve-1  # test mixed case

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/tests/machine_files/head2head/config/config.yaml

@@ -13,45 +13,65 @@ playfields:
 switches:
   s_trough1_front:
     number:
+    playfield: playfield_front
   s_trough2_front:
     number:
+    playfield: playfield_front
   s_trough3_front:
     number:
+    playfield: playfield_front
   s_trough4_front:
     number:
+    playfield: playfield_front
   s_trough1_back:
     number:
+    playfield: playfield_back
   s_trough2_back:
     number:
+    playfield: playfield_back
   s_trough3_back:
     number:
+    playfield: playfield_back
   s_trough4_back:
     number:
+    playfield: playfield_back
   s_launcher_lane_front:
     number:
+    playfield: playfield_front
   s_launcher_lane_back:
     number:
+    playfield: playfield_back
   s_middle_front1:
     number:
+    playfield: playfield_front
   s_middle_back1:
     number:
+    playfield: playfield_front
   s_feeder_front:
     number:
+    playfield: playfield_front
   s_feeder_back:
     number:
+    playfield: playfield_back
   s_launcher_diverter_front:
     number:
+    playfield: playfield_front
   s_launcher_diverter_back:
     number:
+    playfield: playfield_back
   s_transfer_front_back:
     number:
+    playfield: playfield_back
   s_transfer_back_front:
     number:
+    playfield: playfield_front
   s_playfield_front:
     number:
+    playfield: playfield_front
     tags: playfield_front_active
   s_playfield_back:
     number:
+    playfield: playfield_back
     tags: playfield_back_active
 
 coils:

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/tests/machine_files/spinners/config/test_spinners.yaml

@@ -9,6 +9,8 @@ switches:
     number:
   switch4:
     number:
+  switch5:
+    number:
 
 spinners:
   spin1:
@@ -24,4 +26,7 @@ spinners:
     switches: switch4
     active_ms: 400
     idle_ms: 800
-    reset_when_inactive: false
+    reset_when_inactive: false
+  spin_with_buffer:
+    switches: switch5
+    max_events_per_second: 2

{mpf-0.57.2.dev3 → mpf-0.57.2.dev5}/mpf/tests/test_Fast_Exp.py

@@ -80,6 +80,18 @@ class TestFastExp(TestFastBase):
         self.assertIn("88121", self.fast_exp_leds)
         self.assertIn("89200", self.fast_exp_leds)
 
+        # Make sure explicit offset declarations work
+        self.assertEqual(self.led4.hw_drivers['red'][0].number, '88120-0')
+        self.assertEqual(self.led4.hw_drivers['green'][0].number, '88120-1')
+        self.assertEqual(self.led4.hw_drivers['blue'][0].number, '88120-2')
+        self.assertEqual(self.led5.hw_drivers['red'][0].number, '88121-1')
+        self.assertEqual(self.led5.hw_drivers['green'][0].number, '88121-2')
+        self.assertEqual(self.led5.hw_drivers['blue'][0].number, '88122-0')
+        self.assertEqual(self.led6.hw_drivers['red'][0].number, '89200-2')
+        self.assertEqual(self.led6.hw_drivers['green'][0].number, '89201-0')
+        self.assertEqual(self.led6.hw_drivers['blue'][0].number, '89201-1')
+
+
         # Make sure all the RGBW, channels, previous, and start_channels are working
         self.assertEqual(self.led22.hw_drivers['red'][0].number, '48002-0')
         self.assertEqual(self.led22.hw_drivers['green'][0].number, '48002-1')
@@ -110,6 +122,13 @@ class TestFastExp(TestFastBase):
         self.assertEqual(self.led29.hw_drivers['green'][0].number, '48009-2')
         self.assertEqual(self.led29.hw_drivers['blue'][0].number, '48009-1')
         self.assertEqual(self.led29.hw_drivers['white'][0].number, '4800A-2')
+        self.assertEqual(self.led30.hw_drivers['red'][0].number, 'B406B-0')
+        self.assertEqual(self.led30.hw_drivers['green'][0].number, 'B406B-1')
+        self.assertEqual(self.led30.hw_drivers['blue'][0].number, 'B406B-2')
+        self.assertEqual(self.led31.hw_drivers['red'][0].number, 'B406C-0')
+        self.assertEqual(self.led31.hw_drivers['green'][0].number, 'B406C-1')
+        self.assertEqual(self.led31.hw_drivers['blue'][0].number, 'B406C-2')
+
 
     def _test_led_colors(self):