mpf 0.57.0.dev32__tar.gz → 0.57.0.dev34__tar.gz

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/PKG-INFO

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

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/_version.py

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

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/commands/game.py

@@ -106,7 +106,7 @@ class Command:
                             const=logging.DEBUG,
                             default=logging.INFO,
                             help="Enables verbose logging to the console. DO "
-                                 "NOTE: On Windows platforms you must also use -v for "
+                                 "NOTE: you must also use -v for "
                                  "this to work.")
 
         parser.add_argument("-x",
@@ -168,7 +168,10 @@ class Command:
             console_log.setLevel(logging.ERROR)
         else:
             console_log = logging.StreamHandler()
-            console_log.setLevel(self.args.consoleloglevel)
+            if self.args.production:
+                console_log.setLevel(logging.ERROR)
+            else:
+                console_log.setLevel(self.args.consoleloglevel)
 
         console_log.setFormatter(logging.Formatter(
             '%(asctime)s.%(msecs)03d : %(levelname)s [%(name)s] %(message)s', "%H:%M:%S"))
@@ -177,7 +180,7 @@ class Command:
         console_log_queue = Queue()
         console_queue_handler = QueueHandler(console_log_queue)
         self.console_queue_listener = logging.handlers.QueueListener(
-            console_log_queue, console_log)
+            console_log_queue, console_log, respect_handler_level=True)
         self.console_queue_listener.start()
 
         # initialize file log

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/config_spec.yaml

@@ -286,6 +286,8 @@ bonus_mode_settings:
     end_bonus_event: single|event_handler|None
     keep_multiplier: single|template_bool|False
     bonus_entries: list|subconfig(bonus_entries)|
+    rounding_value: single|int|None
+    rounding_direction: single|str|up
 bonus_entries:
     event: single|event_posted|
     score: single|template_int|
@@ -663,6 +665,7 @@ fast_aud:
     port: list|str|auto
     baud: single|int|230400
     debug: single|bool|false
+    optional: single|bool|false
     console_log: single|enum(none,basic,full)|none
     file_log: single|enum(none,basic,full)|basic
     pin1_pulse_time: single|ms|100
@@ -692,7 +695,7 @@ fast_aud:
     headphones_levels_list: list|int|None
     headphones_level: single|enum(headphones,line)|headphones
     mute_speakers_with_headphones: single|bool|true
-    link_main_to_main: single|bool|true
+    link_main_to_main: single|bool|false
     link_sub_to_main: single|bool|true
     link_headphones_to_main: single|bool|false
 
@@ -1560,6 +1563,7 @@ shots:
     delay_switch: dict|machine(switches):ms|None
     persist_enable: single|bool|true
     playfield: single|machine(playfields)|playfield
+    priority: single|int|0
     mark_playfield_active: single|bool|true
     enable_events: event_handler|event_handler:ms|None
     disable_events: event_handler|event_handler:ms|None
@@ -1812,6 +1816,7 @@ sound_system:
 sound_system_tracks:
     type: single|enum(standard,sound_loop,playlist)|standard
     volume: single|gain|0.5
+    label: single|str|None
     events_when_played: list|event_posted|None
     events_when_stopped: list|event_posted|None
     events_when_paused: list|event_posted|None
@@ -1921,6 +1926,7 @@ steppers:
     __valid_in__: machine
     __type__: device
     named_positions: dict|float:str|None
+    home_events: event_handler|event_handler:ms|None
     homing_mode: single|enum(hardware,switch)|hardware
     homing_switch: single|machine(switches)|None
     homing_direction: single|enum(clockwise,counterclockwise)|clockwise
@@ -1930,6 +1936,7 @@ steppers:
     ball_search_max: single|int|1
     ball_search_wait: single|ms|5s
     include_in_ball_search: single|bool|true
+    relative_positions: dict|float:str|None
     reset_position: single|int|0
     reset_events: event_handler|event_handler:ms|machine_reset_phase_3, ball_starting, ball_will_end, service_mode_entered
     number: single|str|
@@ -2190,6 +2197,7 @@ widgets:
         timing: single|enum(after_previous,with_previous)|after_previous
         repeat: single|bool_or_token|false
         easing: single|str|linear
+        step: single|float|0.0
     bezier:
         points: list|num_or_token|
         thickness: single|float_or_token|1.0
@@ -2317,6 +2325,7 @@ widgets:
         force_complete_event: single|event_handler|None
         block_events: list|event_handler|None
         release_events: list|event_handler|None
+        bitmap_font: single|bool_or_token|false
         bold: single|bool_or_token|false
         italic: single|bool_or_token|false
         number_grouping: single|bool_or_token|false

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/core/assets.py

@@ -575,7 +575,7 @@ class BaseAssetManager(MpfController, LogMixin):
 
         if not remaining:
             if self._start_time:
-                self.log.info("Asset loading took: %s", time.time() - self._start_time)
+                self.info_log("Asset loading took: %s", time.time() - self._start_time)
             self._last_asset_event_time = None
             self.machine.events.post('asset_loading_complete')
             '''event: asset_loading_complete
@@ -833,6 +833,9 @@ class AssetPool:
 
     def _get_random_force_all_asset(self) -> Optional[AssetClass]:
         conditional_assets = self._get_conditional_assets()  # Store to variable to avoid calling twice
+        # Different players may have different conditions, so remove any unapplicable ones
+        # Otherwise a previous player may "use up" all the assets of the next player
+        self._assets_sent = set(a for a in self._assets_sent if a in conditional_assets)
         if len(self._assets_sent) == len(conditional_assets):
             self._assets_sent = set()
 

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/core/data_manager.py

@@ -116,19 +116,29 @@ class DataManager(MpfController):
 
     def _writing_thread(self):  # pragma: no cover
         # prevent early writes at start-up
+        data = None
         time.sleep(self.min_wait_secs)
         while not self.machine.thread_stopper.is_set():
             if not self._dirty.wait(1):
                 continue
+            while FileManager.is_busy:
+                time.sleep(0.2)
             self._dirty.clear()
 
             data = copy.deepcopy(self.data)
-            self.debug_log("Writing %s to: %s", self.name, self.filename)
             # save data
-            FileManager.save(self.filename, data)
+            try:
+                FileManager.save(self.filename, data)
+            except Exception as e:
+                # If the file writer has an exception handle it here. Otherwise
+                # this thread will die and all subsequent write attempts will no-op.
+                self.info_log("ERROR writing file %s: %s", self.filename, e)
+            data = None
             # prevent too many writes
             time.sleep(self.min_wait_secs)
 
         # if dirty write data one last time during shutdown
-        if self._dirty.is_set():
+        if data and self._dirty.is_set():
+            while FileManager.is_busy:
+                time.sleep(0.2)
             FileManager.save(self.filename, data)

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/core/file_manager.py

@@ -20,6 +20,7 @@ class FileManager:
     log = logging.getLogger('FileManager')
     file_interfaces = dict()    # type: Dict[str, YamlInterface]
     initialized = False
+    is_busy = False
 
     @classmethod
     def init(cls):
@@ -109,6 +110,12 @@ class FileManager:
         if not FileManager.initialized:
             FileManager.init()
 
+        # FileManager is a singleton and many threads may attempt to write
+        # concurrently. Ruamel has a known issue where concurrent writes
+        # on a YamlInterface will throw. Set a flag to prevent multiple
+        # data writes concurrently.
+        # TODO: Create FileManager instances for each DataManager instance.
+        FileManager.is_busy = True
         ext = os.path.splitext(filename)[1]
 
         # save to temp file and move afterwards. prevents broken files
@@ -121,3 +128,4 @@ class FileManager:
 
         # move temp file
         os.replace(temp_file, filename)
+        FileManager.is_busy = False

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/core/mode.py

@@ -105,6 +105,11 @@ class Mode(LogMixin):
         """Return *True* if this mode is active."""
         return self._active
 
+    @property
+    def starting(self) -> bool:
+        """Return *True* if this mode is starting."""
+        return self._starting
+
     @active.setter
     def active(self, new_active: bool):
         """Setter for _active."""

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/devices/shot.py

@@ -80,14 +80,15 @@ class Shot(EnableDisableMixin, ModeDevice):
         self._handlers = []
         for switch in self.config['switches']:
             self._handlers.append(self.machine.events.add_handler("{}_active".format(switch.name),
-                                                                  self.event_hit, priority=self.mode.priority,
+                                                                  self.event_hit,
+                                                                  priority=self.mode.priority + self.config['priority'],
                                                                   blocking_facility="shot"))
 
         for switch in list(self.config['delay_switch'].keys()):
             self._handlers.append(self.machine.events.add_handler("{}_active".format(switch.name),
                                                                   self._delay_switch_hit,
                                                                   switch_name=switch.name,
-                                                                  priority=self.mode.priority,
+                                                                  priority=self.mode.priority + self.config['priority'],
                                                                   blocking_facility="shot"))
 
     def _remove_switch_handlers(self):
@@ -281,7 +282,8 @@ class Shot(EnableDisableMixin, ModeDevice):
         if self.profile.config['block']:
             min_priority = kwargs.get("_min_priority", {"all": 0})
             min_shots = min_priority.get("shot", 0)
-            min_priority["shot"] = self.mode.priority if self.mode.priority > min_shots else min_shots
+            shot_priority = self.mode.priority + self.config["priority"]
+            min_priority["shot"] = shot_priority if shot_priority > min_shots else min_shots
             return {"_min_priority": min_priority}
 
         return None

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/devices/stepper.py

@@ -1,4 +1,4 @@
-"""Implements a servo in MPF."""
+"""Implements a stepper in MPF."""
 import asyncio
 
 from typing import Optional
@@ -55,6 +55,12 @@ class Stepper(SystemWideDevice):
                                             self.event_move_to_position,
                                             position=position)
 
+        for position in self.config['relative_positions']:
+            self.machine.events.add_handler(self.config['relative_positions'][position],
+                                            self.event_move_to_position,
+                                            position=position,
+                                            is_relative=True)
+
         if not self.platform.features['allow_empty_numbers'] and self.config['number'] is None:
             self.raise_config_error("Stepper must have a number.", 2)
 
@@ -97,11 +103,18 @@ class Stepper(SystemWideDevice):
 
         while True:
             # wait until we should be moving
+            self.debug_log("Waiting for stepper to move...")
             await self._is_moving.wait()
+            if not self._is_homed:
+                await self._home()
+                self._post_ready_event()
+                continue
+            self.debug_log("Moving the stepper!")
             self._is_moving.clear()
             # store target position in local variable since it may change in the meantime
             target_position = self._target_position
             delta = target_position - self._current_position
+            self.debug_log("Stepper moving relative %s to hit target %s from %s", delta, target_position, self._current_position)
             if delta != 0:
                 self.debug_log("Got move command. Current position: %s Target position: %s Delta: %s",
                                self._current_position, target_position, delta)
@@ -118,8 +131,8 @@ class Stepper(SystemWideDevice):
             self.debug_log("Move completed")
 
     def _move_to_absolute_position(self, position):
-        """Move servo to position."""
-        self.debug_log("Moving to position %s", position)
+        """Move stepper to position."""
+        self.debug_log("Moving stepper %s to absolute position %s", self.hw_stepper, position)
         if self.config['pos_min'] <= position <= self.config['pos_max']:
             self._target_position = position
             self._is_moving.set()
@@ -168,6 +181,14 @@ class Stepper(SystemWideDevice):
             self._move_task.cancel()
             self._move_task = None
 
+    @event_handler(1)
+    def event_home(self, **kwargs):
+        """Event handler for home event."""
+        del kwargs
+        self._target_position = 0
+        self._is_homed = False
+        self._is_moving.set()
+
     @event_handler(1)
     def event_reset(self, **kwargs):
         """Event handler for reset event."""
@@ -179,20 +200,21 @@ class Stepper(SystemWideDevice):
         self._move_to_absolute_position(self.config['reset_position'])
 
     @event_handler(5)
-    def event_move_to_position(self, position=None, **kwargs):
+    def event_move_to_position(self, position=None, is_relative=False, **kwargs):
         """Event handler for move_to_position event."""
         del kwargs
         if position is None:
             raise AssertionError("move_to_position event is missing a position.")
 
-        self.move_to_position(position)
+        self.move_to_position(position, is_relative)
 
-    def move_to_position(self, position):
+    def move_to_position(self, position, is_relative=False):
         """Move stepper to a position."""
-        self._target_position = position
+        self.debug_log("Stepper at %s moving to %s position %s", self._current_position, "relative" if is_relative else "absolute", position)
+        self._target_position = (self._current_position + position) if is_relative else position
         if self._ball_search_started:
             return
-        self._move_to_absolute_position(position)
+        self._move_to_absolute_position(self._target_position)
 
     def _ball_search_start(self, **kwargs):
         del kwargs

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/modes/bonus/code/bonus.py

@@ -100,6 +100,13 @@ class Bonus(Mode):
             self._bonus_next_item()
             return
 
+        if self.settings["rounding_value"] and (r := (score % self.settings["rounding_value"])):
+            self.debug_log("rounding bonus score %s remainder of %s", score, r)
+            if self.settings["rounding_direction"] == "down":
+                score -= r
+            else:
+                score += self.settings["rounding_value"] - r
+
         self.debug_log("Bonus Entry '{}': score: {} player_score_entry: {}={}".
                        format(entry['event'], score,
                               entry['player_score_entry'], hits))

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/modes/service/code/service.py

@@ -122,6 +122,7 @@ sort_devices_by_number: single|bool|True
             ServiceMenuEntry("Audits Menu", self._audits_menu),
             ServiceMenuEntry("Adjustments Menu", self._adjustments_menu),
             ServiceMenuEntry("Utilities Menu", self._utilities_menu),
+            ServiceMenuEntry("Audio Menu", self._audio_menu)
 
         ]
         return entries
@@ -184,6 +185,28 @@ sort_devices_by_number: single|bool|True
     async def _adjustments_menu(self):
         await self._make_menu(self._load_adjustments_menu_entries())
 
+    # Audio
+    def _load_audio_menu_entries(self) -> List[ServiceMenuEntry]:
+        """Return the audio menu items with label and callback."""
+        items = [
+            ServiceMenuEntry("Software Levels", self._volume_menu)
+        ]
+
+        self.debug_log("Looking for platform volumes: %s", self.machine.hardware_platforms)
+        for p, platform in self.machine.hardware_platforms.items():
+            # TODO: Define an AudioInterface base class
+            if getattr(platform, "audio_interface", None):
+                self.debug_log("Found '%s' platform audio for volume: %s", p, platform)
+                # TODO: find a good way to get a name of a platform
+                name = p.title()
+                items.append(ServiceMenuEntry(f"{name} Levels", partial(self._volume_menu, platform)))
+            else:
+                self.debug_log("Platform '%s' has no audio to configure volume: %s", p, platform)
+        return items
+
+    async def _audio_menu(self):
+        await self._make_menu(self._load_audio_menu_entries())
+
     # Utilities
     def _load_utilities_menu_entries(self) -> List[ServiceMenuEntry]:
         """Return the utilities menu items with label and callback."""
@@ -433,6 +456,120 @@ sort_devices_by_number: single|bool|True
 
         self.machine.events.post("service_light_test_stop")
 
+    async def _volume_menu(self, platform=None):
+        position = 0
+        if platform:
+            item_configs = platform.audio_interface.amps
+        else:
+            item_configs = self.machine.config["sound_system"]["tracks"]
+        items = [{
+                    **config,
+                    "name": config.get("name", track),
+                    "label": config.get("label", track),
+                    "is_platform": bool(platform),
+                    # TODO: Give each software track a 'name' property
+                    "value": self.machine.variables.get_machine_var(f"{config['name'] if platform else track}_volume") or config['volume']
+                 } for track, config in item_configs.items()]
+
+        # do not crash if no items
+        if not items:   # pragma: no cover
+            return
+
+        # Convert floats to ints for systems that use 0.0-1.0 for volume
+        for item in items:
+            if isinstance(item['value'], float):
+                item['value'] = int(item['value'] * 100)
+
+        # If supported on hardware platform, add option to write to firmware
+        if platform and hasattr(platform.audio_interface, "save_settings_to_firmware"):
+            items.append({
+                "name": "write_to_firmware",
+                "label": "Write Settings",
+                "is_platform": True,
+                "value": "Confirm",
+                "levels_list": ["Confirm", "Saved"]
+            })
+
+        self._update_volume_slide(items, position)
+
+        while True:
+            key = await self._get_key()
+            if key == 'ESC':
+                break
+            if key == 'UP':
+                position += 1
+                if position >= len(items):
+                    position = 0
+                self._update_volume_slide(items, position)
+            elif key == 'DOWN':
+                position -= 1
+                if position < 0:
+                    position = len(items) - 1
+                self._update_volume_slide(items, position)
+            elif key == 'ENTER':
+                # change setting
+                await self._volume_change(items, position, platform, focus_change="enter")
+
+        self.machine.events.post("service_volume_stop")
+
+
+    def _update_volume_slide(self, items, position, is_change=False, focus_change=None):
+        config = items[position]
+        event = "service_volume_{}".format("edit" if is_change else "start")
+        # The 'focus_change' argument can be used to start/stop sound files playing
+        # during the service menu, to test volume.
+        self.machine.events.post(event,
+                                 settings_label=config["label"],
+                                 value_label=config["value"],
+                                 track=config["name"],
+                                 is_platform=config["is_platform"],
+                                 focus_change=focus_change)
+
+    async def _volume_change(self, items, position, platform, focus_change=None):
+        self._update_volume_slide(items, position, focus_change=focus_change)
+        if items[position].get("levels_list"):
+            values = items[position]["levels_list"]
+        else:
+            # Use ints for values to avoid floating-point comparisons
+            values = [int((0.05 * i) * 100) for i in range(0,21)]
+        value_position = values.index(items[position]["value"])
+        self._update_volume_slide(items, position, is_change=True)
+
+        while True:
+            key = await self._get_key()
+            new_value = None
+            if key == 'ESC':
+                self._update_volume_slide(items, position, focus_change="exit")
+                break
+            if key == 'UP':
+                value_position += 1
+                if value_position >= len(values):
+                    value_position = 0
+                new_value = values[value_position]
+            elif key == 'DOWN':
+                value_position -= 1
+                if value_position < 0:
+                    value_position = len(values) - 1
+                new_value = values[value_position]
+            if new_value is not None:
+                items[position]['value'] = new_value
+                # Check for a firmware update
+                if items[position]['name'] == "write_to_firmware":
+                    if new_value == "Saved":
+                        platform.audio_interface.save_settings_to_firmware()
+                        # Remove the options from the list
+                        values = ['Saved']
+                        items[position]['levels_list'] = values
+                else:
+                    # Internally tracked values divide by 100 to store a float.
+                    # External (hardware) values, use the value units provided
+                    # TODO: Create an Amp/Track class to internalize this method.
+                    if not items[position].get("levels_list"):
+                        new_value = new_value / 100
+                    self.machine.variables.set_machine_var(f"{items[position]['name']}_volume", new_value, persist=True)
+                self._update_volume_slide(items, position, is_change=True)
+
+    # AUDIT Menu
     def _load_audit_menu_entries(self) -> List[ServiceMenuEntry]:
         """Return the audit menu items with label and callback."""
         return [

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/modes/service_dmd/config/service_dmd.yaml

@@ -93,6 +93,21 @@ slide_player:
     service_settings:
       action: remove
 
+  # volume:
+  service_volume_start:
+    service_settings:
+      action: play
+      priority: 2
+    service_settings_edit:
+      action: remove
+  service_volume_edit:
+    service_settings_edit:
+      action: play
+      priority: 3
+  service_volume_stop:
+    service_settings:
+      action: remove
+
   # audits:
   service_audits_menu_show:
     service_audits_menu:

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/platforms/fast/communicators/aud.py

@@ -29,17 +29,17 @@ class FastAudCommunicator(FastSerialCommunicator):
         self.amps = {
             'main':
                 {'cmd': 'AV',
-                 'volume': '00',
+                 'volume': 0,
                  'enabled': False,
                  },
             'sub':
                 {'cmd': 'AS',
-                 'volume': '00',
+                 'volume': 0,
                  'enabled': False,
                  },
             'headphones':
                 {'cmd': 'AH',
-                 'volume': '00',
+                 'volume': 0,
                  'enabled': False,
                  },
             }
@@ -54,10 +54,12 @@ class FastAudCommunicator(FastSerialCommunicator):
 
     async def soft_reset(self):
         self.update_config(send_now=True)
-        for amp in self.amps:
-            self.set_volume(amp, int(self.amps[amp]['volume'], 16))
+        for amp_name in self.amps:
+            self.set_volume(amp_name, self.amps[amp_name]['volume'])
 
     def _volume_to_hw(self, volume):
+        """Always store and pass volume levels as decimals (0-64), and use this
+        method to convert to hex strings when sending via serial to AUD board."""
         volume = int(volume)
         assert 0 <= volume <= 63, f"Invalid volume {volume}"
         return f"{volume:02X}"
@@ -83,28 +85,31 @@ class FastAudCommunicator(FastSerialCommunicator):
         if send_now:
             self.send_config_to_board()
 
-    def set_volume(self, amp, volume, send_now=True):
-        if amp not in self.amps:
-            raise AssertionError(f"Invalid amp {amp}")
+    def set_volume(self, amp_name, volume, send_now=True):
+        if amp_name not in self.amps:
+            raise AssertionError(f"Invalid amp {amp_name}")
 
-        volume = self._volume_to_hw(volume)
-        self.amps[amp]['volume'] = volume
+        # Track the internal (realtime) volume of the amp, which may be
+        # different than the stored (machine var) volume during ducking
+        self.amps[amp_name]['volume'] = volume
         if send_now:
-            self.send_and_forget(f"{self.amps[amp]['cmd']}:{volume}")
+            hw_volume = self._volume_to_hw(volume)
+            self.send_and_forget(f"{self.amps[amp_name]['cmd']}:{hw_volume}")
 
-    def get_volume(self, amp):
-        return int(self.amps[amp]['volume'], 16)
+    def get_volume(self, amp_name):
+        """Get the current internal volume of the amp."""
+        return self.amps[amp_name]['volume']
 
-    def enable_amp(self, amp, send_now=True):
-        if amp not in self.amps:
-            raise AssertionError(f"Invalid amp {amp}")
-        self.amps[amp]['enabled'] = True
+    def enable_amp(self, amp_name, send_now=True):
+        if amp_name not in self.amps:
+            raise AssertionError(f"Invalid amp {amp_name}")
+        self.amps[amp_name]['enabled'] = True
         self.update_config(send_now)
 
-    def disable_amp(self, amp, send_now=True):
-        if amp not in self.amps:
-            raise AssertionError(f"Invalid amp {amp}")
-        self.amps[amp]['enabled'] = False
+    def disable_amp(self, amp_name, send_now=True):
+        if amp_name not in self.amps:
+            raise AssertionError(f"Invalid amp {amp_name}")
+        self.amps[amp_name]['enabled'] = False
         self.update_config(send_now)
 
     def set_phones_level(self, mode, send_now=True):

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/platforms/fast/communicators/base.py

@@ -73,6 +73,10 @@ class FastSerialCommunicator(LogMixin):
 
     async def connect(self):
         for port in self.config['port']:
+            # If this is an auto-detect that failed to detect, the port will
+            # just be 'auto' and there's no reason to try and connect to it.
+            if port == 'auto':
+                continue
             self.log.info(f"Trying to connect to {port} at {self.config['baud']}bps")
             success = False
 
@@ -88,7 +92,7 @@ class FastSerialCommunicator(LogMixin):
 
                     # if we are in production mode, retry
                     await asyncio.sleep(.1)
-                    self.log.warning("Connection to %s failed. Will retry.", port)
+                    self.log.warning("Connection to port %s failed. Will retry.", port)
                 else:
                     # we got a connection
                     self.log.info(f"Connected to {port} at {self.config['baud']}bps")

{mpf-0.57.0.dev32 → mpf-0.57.0.dev34}/mpf/platforms/fast/fast.py

@@ -117,7 +117,6 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
         self.machine.events.add_async_handler('init_phase_1', self.soft_reset)
         self.machine.events.add_handler('init_phase_3', self._start_communicator_tasks)
         self.machine.events.add_handler('machine_reset_phase_2', self._init_complete)
-        self.audio_interface = self.configure_audio_interface()
         await self._connect_to_hardware()
 
     async def soft_reset(self, **kwargs):
@@ -275,6 +274,10 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
             try:
                 await communicator.connect()
             except SerialException as e:
+                if config.get("optional"):
+                    self.info_log("Unable to connect to %s on port %s, flagged as optional so ignoring", port, config['port'])
+                    del(self.serial_connections[port])
+                    continue
                 raise MpfRuntimeError("Could not open serial port {}. Is something else connected to the port? "
                                       "Did the port number or your computer change? Do you have permissions to the port? "
                                       "".format(port), 1, self.log.name) from e