Improved handling of FAST Audio board

Author: avanwinkle

mpf/modes/high_score/code/high_score.py

@@ -271,6 +271,7 @@ async def _ask_player_for_initials(self, player: Player, award_label: str, value
             input_initials = choice(unused_initials)
         return input_initials
 
+    # pylint: disable-msg=too-many-arguments
     async def _show_award_slide(self, player_num, player_name: str, category_name: str, award: str, value: int) -> None:
         if not self.high_score_config['award_slide_display_time']:
             return

mpf/platforms/fast/fast_audio.py

@@ -2,6 +2,10 @@
 
 from math import ceil
 from mpf.core.logging import LogMixin
+from mpf.core.settings_controller import SettingEntry
+
+VARIABLE_NAME = "fast_audio_%s_volume"
+SETTING_TYPE = "hw_volume"
 
 
 class FASTAudioInterface(LogMixin):
@@ -17,9 +21,9 @@ def __init__(self, platform, communicator):
         self.machine = platform.machine
         self.communicator = communicator
         self.amps = {
-            'main': {'name': 'fast_audio_main', 'label': "Speakers"},
-            'sub': {'name': 'fast_audio_sub', 'label': "Subwoofer"},
-            'headphones': {'name': 'fast_audio_headphones', 'label': "Headphones"}
+            'main': {'name': 'fast_audio_main', 'label': "Speakers", 'sort': 0},
+            'sub': {'name': 'fast_audio_sub', 'label': "Subwoofer", 'sort': 1},
+            'headphones': {'name': 'fast_audio_headphones', 'label': "Headphones", 'sort': 2}
         }
         self.control_pin_pulse_times = list()
 
@@ -35,30 +39,41 @@ def _initialize(self, **kwargs):
         self._register_event_handlers()
 
     def _configure_machine_vars(self):
-        for amp_name in self.amps:
-            var_name = f'fast_audio_{amp_name}_volume'
-
-            # 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'),
-                    persist=self.communicator.config['persist_volume_settings']
-                )
-            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_name}_volume'],
-                    persist=self.communicator.config['persist_volume_settings']
-                )
+        # See if main volume has been defined yet, otherwise use default
+        main_volume = self.machine.variables.get_machine_var('fast_audio_main_volume')
+        if main_volume is None:
+            main_volume = self.communicator.config['default_main_volume']
+
+        for amp_name, settings in self.amps.items():
+
+            default_value = self.communicator.config[f'default_{amp_name}_volume']
+            if self.communicator.config.get(f'link_{amp_name}_to_main', False):
+                machine_var_name = VARIABLE_NAME % "main"
+            else:
+                machine_var_name = VARIABLE_NAME % amp_name
+
+                # Create a machine variable if one doesn't exist
+                if not self.machine.variables.is_machine_var(machine_var_name):
+                    self.machine.variables.set_machine_var(machine_var_name, default_value,
+                                                           self.communicator.config['persist_volume_settings'])
+
+            # Identify the machine var for this amp
+            settings["machine_var"] = machine_var_name
+            self.machine.settings.add_setting(SettingEntry(
+                settings['name'],
+                settings['label'],
+                settings['sort'],
+                machine_var_name,
+                default_value,
+                None,
+                SETTING_TYPE
+            ))
 
     def _init_amps(self):
         for amp_name, amp in self.amps.items():
             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
@@ -71,7 +86,8 @@ def _init_amps(self):
                 # if we have a levels list in the config, make sure the steps num is right
                 amp['steps'] = len(amp['levels_list']) - 1
 
-            if amp['link_to_main'] and len(amp['levels_list']) != len(self.amps['main']['levels_list']):
+            if self.communicator.config[f'link_{amp_name}_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_name} has {len(amp['levels_list'])} steps.")
@@ -135,7 +151,6 @@ def send_volume_to_hw(self, amp_name=None, send_now=True):
             for each_amp_name in self.amps:
                 self.send_volume_to_hw(each_amp_name, send_now)
             return
-
         self.communicator.set_volume(amp_name, self.get_volume(amp_name), send_now)
 
     def _set_volume(self, amp_name, value=0, **kwargs):
@@ -155,19 +170,13 @@ def _set_volume(self, amp_name, value=0, **kwargs):
         #self.platform.debug_log("Writing FAST amp volume %s to %s (decimal)", amp_name, value)
         self.send_volume_to_hw(amp_name)
 
-        if amp_name == 'main':
-            for other_amp_name, other_amp in self.amps.items():
-                if other_amp_name != amp_name and other_amp['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_name, **kwargs):
         """Return the current volume of the specified amp."""
         del kwargs
-        return self.machine.variables.get_machine_var(f'fast_audio_{amp_name}_volume')
+        return self.machine.variables.get_machine_var(self.amps[amp_name]["machine_var"]) or 0
 
     def _set_machine_var_volume(self, amp_name, value):
-        self.machine.variables.set_machine_var(f'fast_audio_{amp_name}_volume', value)
+        self.machine.variables.set_machine_var(self.amps[amp_name]["machine_var"], value)
 
     def temp_volume(self, amp_name, change=1, **kwargs):
         """Temporarily change the volume by the specified number of units, up or down.

mpf/tests/machine_files/fast/config/audio.yaml

@@ -22,6 +22,14 @@ fast:
     power_pulse_time: 98
     reset_pulse_time: 97
 
+machine_vars:
+  fast_audio_sub_volume:
+    initial_value: 9
+  fast_audio_main_volume:
+    initial_value: 8
+  fast_audio_headphones_volume:
+    initial_value: 10
+
 variable_player:
   increase_main_volume:
     fast_audio_main_volume:

mpf/tests/machine_files/fast/config/audio2.yaml

@@ -27,6 +27,7 @@ fast:
       - 14
       - 15
     headphones_level: line
+    link_sub_to_main: true
 
 machine_vars:
   fast_audio_main_volume:

mpf/tests/test_Fast_Audio.py

@@ -25,10 +25,15 @@ def create_expected_commands(self):
             self.serial_connections['aud'].autorespond_commands['WD:3E8'] = 'WD:3E8,03'
 
         else:
-            self.serial_connections['aud'].expected_commands = {'AM:0B':'AM:0B',
-                                                                'AV:08':'AV:08',
-                                                                'AS:09':'AS:09',
-                                                                'AH:0A':'AH:0A',}
+            self.serial_connections['aud'].expected_commands = {
+                # 'AV:00':'AV:00',
+                # 'AS:00':'AS:00',
+                # 'AH:00':'AH:00',
+                'AM:0B':'AM:0B',
+                'AV:08':'AV:08',
+                'AS:09':'AS:09',
+                'AH:0A':'AH:0A',
+            }
 
     def test_audio_basics(self):
 
@@ -69,10 +74,6 @@ def test_audio_basics(self):
         self.assertTrue(fast_audio.communicator.amps['sub']['enabled'])
         self.assertTrue(fast_audio.communicator.amps['headphones']['enabled'])
 
-        self.assertFalse(fast_audio.amps['main']['link_to_main'])
-        self.assertFalse(fast_audio.amps['sub']['link_to_main'])
-        self.assertFalse(fast_audio.amps['headphones']['link_to_main'])
-
         # Change the volume var and make sure it's reflected in the hardware
         self.aud_cpu.expected_commands['AV:0D'] = 'AV:0D'
         self.machine.variables.set_machine_var('fast_audio_main_volume', 13)
@@ -113,9 +114,13 @@ def test_control_pins(self):
     @test_config('audio2.yaml')
     def test_machine_var_loading(self):
         fast_audio = self.machine.default_platform.audio_interface
+        self.advance_time_and_run()
         self.assertEqual(15, self.machine.variables.get_machine_var('fast_audio_main_volume'))
+        self.assertEqual(15, fast_audio.get_volume('main'))
         self.assertEqual(15, fast_audio.communicator.amps['main']['volume'])
+        # sub has a machine value set in the configs, which is persisted
+        self.assertEqual(2, self.machine.variables.get_machine_var('fast_audio_sub_volume'))
         # sub is linked to main, so it will be 15 even though the config value is 2
-        self.assertEqual(15, self.machine.variables.get_machine_var('fast_audio_sub_volume'))
+        self.assertEqual(15, fast_audio.get_volume('main'))
         self.assertEqual(15, fast_audio.communicator.amps['sub']['volume'])
         self.assertEqual(17, self.machine.variables.get_machine_var('fast_audio_headphones_volume'))