diff --git a/mpf/config_spec.yaml b/mpf/config_spec.yaml
index afe7a653e..9772cb31c 100644
--- a/mpf/config_spec.yaml
+++ b/mpf/config_spec.yaml
@@ -1232,6 +1232,8 @@ snux:
     platform: single|str|None
     console_log: single|enum(none,basic,full)|none
     file_log: single|enum(none,basic,full)|basic
+    prefer_a_side_event: single|str|game_ended
+    prefer_c_side_event: single|str|game_will_start
 smartmatrix:
     __valid_in__: machine
     port: single|str|
diff --git a/mpf/platforms/snux.py b/mpf/platforms/snux.py
index d92e3c81a..ce17d8026 100644
--- a/mpf/platforms/snux.py
+++ b/mpf/platforms/snux.py
@@ -47,6 +47,11 @@ class SnuxHardwarePlatform(DriverPlatform):
         self.c_side_enabled = False
 
         self.ac_relay_in_transition = False
+        # Specify whether the AC relay should favour the A or C side when at rest.
+        # Typically during a game the 'C' side should be preferred, since that is
+        # normally where the flashers are which need a quick response without having to wait on the relay.
+        # At game over though, it should prefer the 'A' side so that the relay isn't permanently energised.
+        self.prefer_a_side = True
 
     def stop(self):
         """Stop the overlay. Nothing to do here because stop is also called on parent platform."""
@@ -62,6 +67,16 @@ class SnuxHardwarePlatform(DriverPlatform):
         """Return if C side cannot be switches off right away."""
         return self.drivers_holding_c_side or self.c_side_done_time > self.machine.clock.get_time()
 
+    @property
+    def c_side_busy(self):
+        """Return if C side cannot be switches off right away."""
+        return self.drivers_holding_c_side or self.c_side_done_time > self.machine.clock.get_time() or self.c_side_queue
+
+    @property
+    def a_side_active(self):
+        """Return if A side cannot be switches off right away."""
+        return self.drivers_holding_a_side or self.a_side_done_time > self.machine.clock.get_time()
+
     def _null_log_handler(self, *args, **kwargs):
         pass
 
@@ -105,6 +120,22 @@ class SnuxHardwarePlatform(DriverPlatform):
         self.machine.events.add_handler('init_phase_5',
                                         self._initialize_phase_2)
 
+        self.machine.events.add_handler(self.snux_config['prefer_a_side_event'], self._prefer_a_side)
+        self.log.info("Configuring Snux driver to prefer A side on event %s", self.snux_config['prefer_a_side_event'])
+
+        self.machine.events.add_handler(self.snux_config['prefer_c_side_event'], self._prefer_c_side)
+        self.log.info("Configuring Snux driver to prefer C side on event %s", self.snux_config['prefer_c_side_event'])
+
+    def _prefer_a_side(self, **kwargs):
+        del kwargs
+        self.prefer_a_side = True
+        self._enable_a_side()
+
+    def _prefer_c_side(self, **kwargs):
+        del kwargs
+        self.prefer_a_side = False
+        self._enable_c_side()
+
     def _initialize_phase_2(self, **kwargs):
         del kwargs
         self.machine.clock.schedule_interval(self._flash_diag_led, 0.5)
@@ -121,12 +152,20 @@ class SnuxHardwarePlatform(DriverPlatform):
 
         Called based on the timer_tick event
         """
-        if self.a_side_queue:
-            self._service_a_side()
-        elif self.c_side_queue:
-            self._service_c_side()
-        elif self.c_side_enabled and not self.c_side_active:
-            self._enable_a_side()
+        if self.prefer_a_side:
+            if self.a_side_queue:
+                self._service_a_side()
+            elif self.c_side_queue:
+                self._service_c_side()
+            elif self.c_side_enabled and not self.c_side_active:
+                self._enable_a_side()
+        else:
+            if self.c_side_queue:
+                self._service_c_side()
+            elif self.a_side_queue:
+                self._service_a_side()
+            elif self.a_side_enabled and not self.a_side_active:
+                self._enable_c_side()
 
     def _flash_diag_led(self):
         """Flash diagnosis LED."""
@@ -216,13 +255,22 @@ class SnuxHardwarePlatform(DriverPlatform):
 
         This action will be serviced immediately if it can, or ASAP otherwise.
         """
-        if driver in self.a_drivers:
-            self.a_side_queue.add((driver, pulse_settings, hold_settings))
-            self._service_a_side()
-        elif driver in self.c_drivers:
-            self.c_side_queue.add((driver, pulse_settings, hold_settings))
-            if not self.ac_relay_in_transition and not self.a_side_busy:
+        if self.prefer_a_side:
+            if driver in self.a_drivers:
+                self.a_side_queue.add((driver, pulse_settings, hold_settings))
+                self._service_a_side()
+            elif driver in self.c_drivers:
+                self.c_side_queue.add((driver, pulse_settings, hold_settings))
+                if not self.ac_relay_in_transition and not self.a_side_busy:
+                    self._service_c_side()
+        else:
+            if driver in self.c_drivers:
+                self.c_side_queue.add((driver, pulse_settings, hold_settings))
                 self._service_c_side()
+            elif driver in self.a_drivers:
+                self.a_side_queue.add((driver, pulse_settings, hold_settings))
+                if not self.ac_relay_in_transition and not self.c_side_busy:
+                    self._service_a_side()
 
     def _enable_ac_relay(self):
         self.system11_config['ac_relay_driver'].enable()
@@ -245,27 +293,46 @@ class SnuxHardwarePlatform(DriverPlatform):
     # -------------------------------- A SIDE ---------------------------------
 
     def _enable_a_side(self):
-        if not self.a_side_enabled and not self.ac_relay_in_transition:
-
-            if self.c_side_active:
-                self._disable_all_c_side_drivers()
+        if self.prefer_a_side:
+            if not self.a_side_enabled and not self.ac_relay_in_transition:
+
+                if self.c_side_active:
+                    self._disable_all_c_side_drivers()
+                    self._disable_ac_relay()
+                    self.delay.add(ms=self.system11_config['ac_relay_delay_ms'],
+                                   callback=self._enable_a_side,
+                                   name='enable_a_side')
+                    return
+
+                elif self.c_side_enabled:
+                    self._disable_ac_relay()
+
+                else:
+                    self._a_side_enabled()
+        else:
+            if (not self.ac_relay_in_transition and
+                    not self.a_side_enabled and
+                    not self.c_side_busy):
                 self._disable_ac_relay()
-                self.delay.add(ms=self.system11_config['ac_relay_delay_ms'],
-                               callback=self._enable_a_side,
-                               name='enable_a_side')
-                return
 
-            elif self.c_side_enabled:
-                self._disable_ac_relay()
-
-            else:
-                self._a_side_enabled()
+            elif self.a_side_enabled and self.a_side_queue:
+                self._service_a_side()
 
     def _a_side_enabled(self):
         self.ac_relay_in_transition = False
-        self.a_side_enabled = True
-        self.c_side_enabled = False
-        self._service_a_side()
+        if self.prefer_a_side:
+            self.a_side_enabled = True
+            self.c_side_enabled = False
+            self._service_a_side()
+        else:
+
+            if self.c_side_queue:
+                self._enable_c_side()
+                return
+
+            self.c_side_enabled = False
+            self.a_side_enabled = True
+            self._service_a_side()
 
     def _service_a_side(self):
         if not self.a_side_queue:
@@ -300,24 +367,47 @@ class SnuxHardwarePlatform(DriverPlatform):
     # -------------------------------- C SIDE ---------------------------------
 
     def _enable_c_side(self):
-        if (not self.ac_relay_in_transition and
-                not self.c_side_enabled and
-                not self.a_side_busy):
-            self._enable_ac_relay()
+        if self.prefer_a_side:
+            if not self.c_side_enabled and not self.ac_relay_in_transition:
+
+                if self.a_side_active:
+                    self._disable_all_a_side_drivers()
+                    self._enable_ac_relay()
+                    self.delay.add(ms=self.system11_config['ac_relay_delay_ms'],
+                                   callback=self._enable_c_side,
+                                   name='enable_c_side')
+                    return
+
+                elif self.a_side_enabled:
+                    self._enable_ac_relay()
+
+                else:
+                    self._c_side_enabled()
+        else:
+            if (not self.ac_relay_in_transition and
+                    not self.c_side_enabled and
+                    not self.a_side_busy):
+                self._enable_ac_relay()
 
-        elif self.c_side_enabled and self.c_side_queue:
-            self._service_c_side()
+            elif self.c_side_enabled and self.c_side_queue:
+                self._service_c_side()
 
     def _c_side_enabled(self):
         self.ac_relay_in_transition = False
 
-        if self.a_side_queue:
-            self._enable_a_side()
-            return
+        if self.prefer_a_side:
+            self.c_side_enabled = True
+            self.a_side_enabled = False
+            self._service_c_side()
+        else:
 
-        self.a_side_enabled = False
-        self.c_side_enabled = True
-        self._service_c_side()
+            if self.a_side_queue:
+                self._enable_a_side()
+                return
+
+            self.a_side_enabled = False
+            self.c_side_enabled = True
+            self._service_c_side()
 
     def _service_c_side(self):
         if not self.c_side_queue:
@@ -359,6 +449,14 @@ class SnuxHardwarePlatform(DriverPlatform):
             self.c_side_done_time = 0
             self.c_side_enabled = False
 
+    def _disable_all_a_side_drivers(self):
+        if self.a_side_active:
+            for driver in self.drivers_holding_a_side:
+                driver.disable()
+            self.drivers_holding_a_side = set()
+            self.a_side_done_time = 0
+            self.a_side_enabled = False
+
     def validate_coil_section(self, driver, config):
         """Validate coil config for platform."""
         return self.platform.validate_coil_section(driver, config)

System 11 A/C select relay handling

[snux.zip](https://github.com/missionpinball/mpf/files/2730432/snux.zip)

Add 2 parameters to the snux: platform in config_spec.yaml... (the last 2 in this list)

```
snux:
    __valid_in__: machine
    flipper_enable_driver: single|machine(coils)|
    diag_led_driver: single|machine(coils)|
    platform: single|str|None
    console_log: single|enum(none,basic,full)|none
    file_log: single|enum(none,basic,full)|basic
    prefer_a_side_event: single|str|game_ended
    prefer_c_side_event: single|str|game_will_start
```

Modify the snux.py platform code to know what the A/C relay should do when at rest.  By default during game play it will now rest in the 'C' side (so relay is energised).  Typically flasher lamps are on the C side so they will get a quick response instead of having to wait for the relay to switch.  When the game is over the relay will prefer the 'A' side (so de-energised).  I've attached the snux.py code and the change to config_spec.yaml is mentioned above.  

I also need to update the docs to state that care should be taken if processing a lot of drives to the A and C sides at the same time.  That message applies regardless of this change.
diff --git a/mpf/tests/test_Snux.py b/mpf/tests/test_Snux.py
index f21149f55..46bda22aa 100644
--- a/mpf/tests/test_Snux.py
+++ b/mpf/tests/test_Snux.py
@@ -1,10 +1,9 @@
 """Test snux platform."""
+from mpf.tests.MpfFakeGameTestCase import MpfFakeGameTestCase, MagicMock
 from mpf.platforms.interfaces.driver_platform_interface import PulseSettings, HoldSettings
 
-from mpf.tests.MpfTestCase import MpfTestCase, MagicMock
 
-
-class TestSnux(MpfTestCase):
+class TestSnux(MpfFakeGameTestCase):
     def getConfigFile(self):
         return 'config.yaml'
 
@@ -30,6 +29,22 @@ class TestSnux(MpfTestCase):
                 return driver
         return False
 
+    def test_ac_relay_default(self):
+        # outside game it should be default off
+        c_ac_relay = self.machine.coils["c_ac_relay"]
+        self.assertEqual("disabled", c_ac_relay.hw_driver.state)
+
+        self.start_game()
+        # during a game it should be default on to allow fast flashers
+        self.assertEqual("enabled", c_ac_relay.hw_driver.state)
+
+        # after the game ended it should turn back to default off
+        self.drain_all_balls()
+        self.drain_all_balls()
+        self.drain_all_balls()
+        self.assertGameIsNotRunning()
+        self.assertEqual("disabled", c_ac_relay.hw_driver.state)
+
     def test_ac_switch_and_pulse(self):
         # test diag led flashing. otherwise snux is not running
         c_diag_led_driver = self.machine.coils.c_diag_led_driver

pip install -e .
parse_log_pytest
pytest
pytest
3.6
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
asciimatics==1.14.0
attrs @ file:///opt/conda/conda-bld/attrs_1642510447205/work
certifi==2021.5.30
future==1.0.0
importlib-metadata @ file:///tmp/build/80754af9/importlib-metadata_1631916693255/work
iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
more-itertools @ file:///tmp/build/80754af9/more-itertools_1637733554872/work
-e git+https://github.com/missionpinball/mpf.git@06fc30212bbe3ed4d73dff3bdec8248e1cc7ca28#egg=mpf
packaging @ file:///tmp/build/80754af9/packaging_1637314298585/work
Pillow==8.4.0
pluggy @ file:///tmp/build/80754af9/pluggy_1615976315926/work
psutil==7.0.0
py @ file:///opt/conda/conda-bld/py_1644396412707/work
pyfiglet==0.8.post1
pyparsing @ file:///tmp/build/80754af9/pyparsing_1635766073266/work
pyserial==3.5
pyserial-asyncio==0.6
pytest==6.2.4
ruamel.base==1.0.0
ruamel.yaml==0.10.23
terminaltables==3.1.10
toml @ file:///tmp/build/80754af9/toml_1616166611790/work
typing==3.7.4.3
typing_extensions @ file:///opt/conda/conda-bld/typing_extensions_1647553014482/work
wcwidth==0.2.13
zipp @ file:///tmp/build/80754af9/zipp_1633618647012/work

name: mpf
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - attrs=21.4.0=pyhd3eb1b0_0
  - ca-certificates=2025.2.25=h06a4308_0
  - certifi=2021.5.30=py36h06a4308_0
  - importlib-metadata=4.8.1=py36h06a4308_0
  - importlib_metadata=4.8.1=hd3eb1b0_0
  - iniconfig=1.1.1=pyhd3eb1b0_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.3=he6710b0_2
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - more-itertools=8.12.0=pyhd3eb1b0_0
  - ncurses=6.4=h6a678d5_0
  - openssl=1.1.1w=h7f8727e_0
  - packaging=21.3=pyhd3eb1b0_0
  - pip=21.2.2=py36h06a4308_0
  - pluggy=0.13.1=py36h06a4308_0
  - py=1.11.0=pyhd3eb1b0_0
  - pyparsing=3.0.4=pyhd3eb1b0_0
  - pytest=6.2.4=py36h06a4308_2
  - python=3.6.13=h12debd9_1
  - readline=8.2=h5eee18b_0
  - setuptools=58.0.4=py36h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - toml=0.10.2=pyhd3eb1b0_0
  - typing_extensions=4.1.1=pyh06a4308_0
  - wheel=0.37.1=pyhd3eb1b0_0
  - xz=5.6.4=h5eee18b_1
  - zipp=3.6.0=pyhd3eb1b0_0
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - asciimatics==1.14.0
      - future==1.0.0
      - pillow==8.4.0
      - psutil==7.0.0
      - pyfiglet==0.8.post1
      - pyserial==3.5
      - pyserial-asyncio==0.6
      - ruamel-base==1.0.0
      - ruamel-yaml==0.10.23
      - terminaltables==3.1.10
      - typing==3.7.4.3
      - wcwidth==0.2.13
prefix: /opt/conda/envs/mpf

mpf/tests/test_Snux.py::TestSnux::test_ac_relay_default
mpf/tests/test_Snux.py::TestSnux::test_ac_switch_and_enable mpf/tests/test_Snux.py::TestSnux::test_ac_switch_and_pulse
mpf/platforms/snux.py mpf/config_spec.yaml
mpf/platforms/snux.py mpf/config_spec.yaml