mpf 0.57.0.dev32__tar.gz → 0.57.0.dev33__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.0.dev32
+Version: 0.57.0.dev33
 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.dev33}/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.dev33'  # 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.dev33}/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",
@@ -177,7 +177,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.dev33}/mpf/config_spec.yaml

@@ -663,6 +663,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 +693,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
 
@@ -1812,6 +1813,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

{mpf-0.57.0.dev32 → mpf-0.57.0.dev33}/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.dev33}/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.dev33}/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.dev33}/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.dev33}/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

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

@@ -12,7 +12,11 @@ class FASTAudioInterface(LogMixin):
         self.platform = platform
         self.machine = platform.machine
         self.communicator = communicator
-        self.amps = {'main': {}, 'sub': {}, 'headphones': {}}
+        self.amps = {
+            'main': { 'name': 'fast_audio_main', 'label': "Speakers" },
+            'sub': { 'name': 'fast_audio_sub', 'label': "Subwoofer" },
+            'headphones': { 'name': 'fast_audio_headphones', 'label': "Headphones" }
+        }
         self.control_pin_pulse_times = list()
 
         # need to get this in before the soft_reset(), but after machine vars load
@@ -26,10 +30,12 @@ class FASTAudioInterface(LogMixin):
         self._register_event_handlers()
 
     def _configure_machine_vars(self):
-        for amp in self.amps.keys():
-            var_name = f'fast_audio_{amp}_volume'
+        for amp_name in self.amps.keys():
+            var_name = f'fast_audio_{amp_name}_volume'
 
-            if amp != 'main' and self.communicator.config[f'link_{amp}_to_main']:
+            # Is there a race condition on first boot if the linked amp
+            # comes in the iteration before 'main' is written?
+            if amp_name != 'main' and self.communicator.config[f'link_{amp_name}_to_main']:
                 self.machine.variables.set_machine_var(
                     name=var_name,
                     value=self.machine.variables.get_machine_var('fast_audio_main_volume'),
@@ -37,32 +43,36 @@ class FASTAudioInterface(LogMixin):
 
             elif not self.machine.variables.is_machine_var(var_name):
                 self.machine.variables.set_machine_var(name=var_name,
-                                                    value=self.communicator.config[f'default_{amp}_volume'],
+                                                    value=self.communicator.config[f'default_{amp_name}_volume'],
                                                     persist=self.communicator.config[f'persist_volume_settings'])
     def _init_amps(self):
-        for amp in self.amps.keys():
-            self.amps[amp]['steps'] = self.communicator.config[f'{amp}_steps']
-            self.amps[amp]['max_volume'] = self.communicator.config[f'max_hw_volume_{amp}']
-            self.amps[amp]['levels_list'] = self.communicator.config[f'{amp}_levels_list']
-            self.amps[amp]['link_to_main'] = self.communicator.config[f'link_{amp}_to_main']
+        for amp_name in self.amps.keys():
+            amp = self.amps[amp_name]
+            amp['steps'] = self.communicator.config[f'{amp_name}_steps']
+            amp['max_volume'] = self.communicator.config[f'max_hw_volume_{amp_name}']
+            amp['levels_list'] = self.communicator.config[f'{amp_name}_levels_list']
+            amp['link_to_main'] = self.communicator.config[f'link_{amp_name}_to_main']
 
             # Just set everything here. The communicator will send the
             # config as part of its init process later
-            if self.communicator.config[f'{amp}_amp_enabled']:
-                self.communicator.enable_amp(amp, send_now=False)
+            if self.communicator.config[f'{amp_name}_amp_enabled']:
+                self.communicator.enable_amp(amp_name, send_now=False)
 
-            if not self.amps[amp]['levels_list']:
-                self._create_levels_list(amp)
+            if not amp['levels_list']:
+                self._create_levels_list(amp_name)
             else:
                 # if we have a levels list in the config, make sure the steps num is right
-                self.amps[amp]['steps'] = len(self.amps[amp]['levels_list']) - 1
+                amp['steps'] = len(amp['levels_list']) - 1
 
-            if self.amps[amp]['link_to_main'] and len(self.amps[amp]['levels_list']) != len(self.amps['main']['levels_list']):
-                raise AssertionError(f"Cannot link {amp} to main. The number of volume steps must be the same. "
+            if amp['link_to_main'] and len(amp['levels_list']) != len(self.amps['main']['levels_list']):
+                raise AssertionError(f"Cannot link {amp_name} to main. The number of volume steps must be the same. "
                                      f"Main has {len(self.amps['main']['levels_list'])} steps, "
-                                     f"but {amp} has {len(self.amps[amp]['levels_list'])} steps.")
+                                     f"but {amp_name} has {len(amp['levels_list'])} steps.")
+
+        # Write the volume levels to the hardware layer, but no need to send
+        # them because (regular priority) init_phase_1 includes a soft_reset()
+        self.send_volume_to_hw(send_now=False)
 
-            self.communicator.set_volume(amp, self.get_hw_volume(amp), send_now=False)
 
     def _configure_control_pins(self):
         for i in range(6):
@@ -83,91 +93,80 @@ class FASTAudioInterface(LogMixin):
         self.communicator.set_phones_behavior(phones, send_now=False)
 
     def _register_event_handlers(self):
-        self.platform.machine.events.add_handler('machine_var_fast_audio_main_volume', self.set_volume, amp='main')
-        self.platform.machine.events.add_handler('machine_var_fast_audio_sub_volume', self.set_volume, amp='sub')
-        self.platform.machine.events.add_handler('machine_var_fast_audio_headphones_volume', self.set_volume, amp='headphones')
+        self.platform.machine.events.add_handler('machine_var_fast_audio_main_volume', self._set_volume, amp_name='main')
+        self.platform.machine.events.add_handler('machine_var_fast_audio_sub_volume', self._set_volume, amp_name='sub')
+        self.platform.machine.events.add_handler('machine_var_fast_audio_headphones_volume', self._set_volume, amp_name='headphones')
         self.platform.machine.events.add_handler('fast_audio_temp_volume', self.temp_volume)
         self.platform.machine.events.add_handler('fast_audio_restore', self.restore_volume)
         self.platform.machine.events.add_handler('fast_audio_pulse_lcd_pin', self.pulse_lcd_pin)
         self.platform.machine.events.add_handler('fast_audio_pulse_power_pin', self.pulse_power_pin)
         self.platform.machine.events.add_handler('fast_audio_pulse_reset_pin', self.pulse_reset_pin)
 
-    def _create_levels_list(self, amp):
-        steps = self.communicator.config[f'{amp}_steps']
-        max_volume = self.communicator.config[f'max_hw_volume_{amp}']
+    def _create_levels_list(self, amp_name):
+        steps = self.communicator.config[f'{amp_name}_steps']
+        max_volume = self.communicator.config[f'max_hw_volume_{amp_name}']
         step_percent = 1 / steps
 
         if max_volume > 63:
-            raise AssertionError(f"Invalid max_hw_volume_{amp}: {max_volume}")
+            raise AssertionError(f"Invalid max_hw_volume_{amp_name}: {max_volume}")
 
         for i in range(steps):
             volume = ceil(max_volume * (1 - (i * step_percent)))
-            self.amps[amp]['levels_list'].append(volume)
+            self.amps[amp_name]['levels_list'].append(volume)
 
         # technically our list is number of volume levels + 1, since that's more logicial
         # for humans. e.g. 20 volume steps of 5% each is 0-100% volume, which
         # has 21 items in the list.
-        self.amps[amp]['levels_list'].append(0)
-        self.amps[amp]['levels_list'].reverse()
+        self.amps[amp_name]['levels_list'].append(0)
+        self.amps[amp_name]['levels_list'].reverse()
 
-    def send_volume_to_hw(self, amp=None):
+    def send_volume_to_hw(self, amp_name=None, send_now=True):
         """Send the current volume to the hardware."""
-        if amp is None:
-            for amp in self.amps.keys():
-                self.send_volume_to_hw(amp)
+        if amp_name is None:
+            for amp_name in self.amps.keys():
+                self.send_volume_to_hw(amp_name, send_now)
             return
 
-        self.communicator.set_volume(amp, self.get_hw_volume(amp))
-
-    def get_hw_volume(self, amp):
-        try:
-            return self.amps[amp]['levels_list'][self.get_volume(amp)]
-        except IndexError:
-            raise AssertionError(f"Invalid volume {self.get_volume(amp)} for amp: {amp}.",
-                                 f"There are only {len(self.amps[amp]['levels_list'])} entries in the volume levels list.")
-
-    def increase_volume(self, amp, change=1, **kwargs):
-        """Increase the volume by the specified number of steps."""
-        self.set_volume(amp, self.amps[amp]['volume'] + int(change))
+        self.communicator.set_volume(amp_name, self.get_volume(amp_name), send_now)
 
-    def decrease_volume(self, amp, change=1, **kwargs):
-        """Decrease the volume by the specified number of steps."""
-        self.set_volume(amp, self.amps[amp]['volume'] - int(change))
-
-    def set_volume(self, amp, value=0, **kwargs):
-        """Set the amp volume to the specified level, using the volume map"""
+    def _set_volume(self, amp_name, value=0, **kwargs):
+        """Set the amp volume to the specified level, in absolute units.
+            This is a private method, volume changes should be instigated by
+            updating the corresponding machine variable."""
         value = int(value)
 
-        if value > self.amps[amp]['steps']:
-            value = self.amps[amp]['steps']
+        if value > self.amps[amp_name]['max_volume']:
+            value = self.amps[amp_name]['max_volume']
         elif value < 0:
             value = 0
 
-        self.send_volume_to_hw(amp)
+        #self.platform.debug_log("Writing FAST amp volume %s to %s (decimal)", amp_name, value)
+        self.send_volume_to_hw(amp_name)
 
-        for other_amp in self.amps.keys():
-            if self.amps[other_amp]['link_to_main'] and other_amp != amp:
-                self._set_machine_var_volume(other_amp, self.amps[amp]['levels_list'][value])
-                self.send_volume_to_hw(other_amp)
+        if amp_name == 'main':
+            for other_amp_name in self.amps.keys():
+                if other_amp_name != amp_name and self.amps[other_amp_name]['link_to_main']:
+                    # Update the machine var, which will be caught and handled
+                    self._set_machine_var_volume(other_amp_name, value)
 
-    def get_volume(self, amp, **kwargs):
-        return self.machine.variables.get_machine_var(f'fast_audio_{amp}_volume')
+    def get_volume(self, amp_name, **kwargs):
+        return self.machine.variables.get_machine_var(f'fast_audio_{amp_name}_volume')
 
-    def _set_machine_var_volume(self, amp, value):
-        self.machine.variables.set_machine_var(f'fast_audio_{amp}_volume', value)
+    def _set_machine_var_volume(self, amp_name, value):
+        self.machine.variables.set_machine_var(f'fast_audio_{amp_name}_volume', value)
 
-    def temp_volume(self, amp, change=1, **kwargs):
-        """Temporarily change the volume by the specified number of steps, up or down,
+    def temp_volume(self, amp_name, change=1, **kwargs):
+        """Temporarily change the volume by the specified number of units, up or down,
         but without changing the machine var. This is used for ducking or other
         temporary volume changes where you don't want to save it to disk.
         """
         change = int(change)
-        self.communicator.set_volume(amp, self.amps['main']['levels_list'][self.get_volume(amp) + change],
+        self.communicator.set_volume(amp_name, self.get_volume(amp_name) + change,
                                      send_now=True)
 
-    def restore_volume(self, amp, **kwargs):
+    def restore_volume(self, amp_name, **kwargs):
         """Restore the volume to the value to the machine var value"""
-        self.communicator.set_volume(amp, self.amps['main']['levels_list'][self.get_volume(amp)],
+        self.communicator.set_volume(amp_name, self.get_volume(amp_name),
                                      send_now=True)
 
     def pulse_lcd_pin(self, pin, ms=None, **kwargs):
@@ -194,3 +193,7 @@ class FASTAudioInterface(LogMixin):
         if not ms:
             ms = self.control_pin_pulse_times[7]
         self.communicator.pulse_control_pin(7, ms)
+
+    def save_settings_to_firmware(self, **kwargs):
+        del kwargs
+        self.communicator.save_settings_to_firmware()

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

@@ -64,8 +64,11 @@ class FastPortDetector:
             except SerialException:
                 self.log.error(f"Could not connect to port {port}. Are you connected via CoolTerm? :)")
 
+            self.platform.debug_log(" - success connecting to port %s", port)
             self.task_writers[asyncio.current_task()] = writer
 
+            total_attempts = 5
+            attempts = 0
             while True:
                 writer.write(b'ID:\r')
 
@@ -73,7 +76,11 @@ class FastPortDetector:
                 try:
                     data = await asyncio.wait_for(reader.read(100), timeout=1.0)
                 except asyncio.TimeoutError:
-                    continue  # retry
+                    attempts += 1
+                    if attempts < total_attempts:
+                        continue  # retry
+                    else:
+                        self.platform.debug_log("Unable to get ID: on port %s after %s retries.", port, total_attempts)
 
                 if data:
                     data = data.decode('utf-8', errors='ignore')
@@ -100,4 +107,4 @@ class FastPortDetector:
     def _cleanup_writer(self, task):
         writer = self.task_writers.pop(task, None)
         if writer:
-            writer.close()
+            writer.close()

{mpf-0.57.0.dev32 → mpf-0.57.0.dev33}/mpf/platforms/opp/opp_coil.py

@@ -64,6 +64,7 @@ class OPPSolenoid(DriverPlatformInterface):
         msg.append((mask >> 8) & 0xff)
         msg.append(mask & 0xff)
         msg.extend(OppRs232Intf.calc_crc8_whole_msg(msg))
+        msg.extend(OppRs232Intf.EOM_CMD)
         cmd = bytes(msg)
         if self.sol_card.platform.debug:
             self.log.debug("Triggering solenoid driver: %s", "".join(" 0x%02x" % b for b in cmd))

{mpf-0.57.0.dev32 → mpf-0.57.0.dev33}/mpf/plugins/auditor.py

@@ -224,7 +224,7 @@ class Auditor:
                         self.current_audits['player'][item]['top'],
                         self.config['num_player_top_records']))
 
-                self.current_audits['player'][item]['average'] = (
+                self.current_audits['player'][item]['average'] = int(
                     ((self.current_audits['player'][item]['total'] *
                       self.current_audits['player'][item]['average']) +
                      self.machine.game.player[item]) /

{mpf-0.57.0.dev32 → mpf-0.57.0.dev33}/mpf/tests/MpfTestCase.py

@@ -596,8 +596,9 @@ class MpfTestCase(unittest.TestCase):
             self.loop.run_once()
             if timeout and time.time() > start + timeout:
                 raise AssertionError("Start took more than {}s".format(timeout))
-
         # trigger exception if there was one
+        if self._exception:
+            raise(self._exception['exception'])
         init.result()
 
     def _mock_event_handler(self, event_name, **kwargs):