mpf 0.80.0.dev4__tar.gz → 0.80.0.dev6__tar.gz

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/.prospector.yaml

@@ -23,6 +23,7 @@ pylint:
   disable:
     - pointless-string-statement  # pointless statement, which is how our event docstrings are seen
     - too-few-public-methods
+    - too-many-positional-arguments  # many methods have many positional args
     - unsubscriptable-object    # broken on python 3.9
     # The following linter rules are disabled to make a refactor managable in chunks
     - consider-using-f-string  # temporarily disabling due to the 900+ instances to be replaced

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.80.0.dev4
+Version: 0.80.0.dev6
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -32,6 +32,7 @@ Requires-Dist: psutil==5.9.8
 Requires-Dist: pyserial==3.5
 Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: ruamel.yaml==0.18.6
+Requires-Dist: setuptools~=72.2.0
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
 Requires-Dist: Pillow==9.5.0

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.80.0.dev4'
+__version__ = '0.80.0.dev6'
 '''The full version of MPF.'''
 
 __short_version__ = '0.80'

mpf-0.80.0.dev6/mpf/commands/both.py

@@ -0,0 +1,87 @@
+"""Command which launches both the MPF core engine and MPF-MC."""
+
+from importlib import import_module
+import argparse
+import configparser
+import shutil
+import subprocess
+import os
+import re
+
+
+def _start_mpf(mpf_path, machine_path, args):
+    module = import_module('mpf.commands.game')
+    module.Command(mpf_path, machine_path, args)
+
+
+def _spawn_gmc(gmc_args, mpf_args):
+    full_godot_exec_path = shutil.which(gmc_args.godot_exec_path)
+
+    # Verify that the godot executable exists
+    if not full_godot_exec_path:
+        raise FileNotFoundError("Unable to find Godot executable at '%s'. Please check this file, "
+                                "your PATH, or specify an executable with the -G argument." % gmc_args.godot_exec_path)
+
+    full_gmc_project_path = os.path.join(gmc_args.gmc_project_path, "project.godot")
+    try:
+        os.stat(full_gmc_project_path)
+    except FileNotFoundError:
+        raise FileNotFoundError("Unable to find GMC project.godot file in '%s'. Please check this folder "
+                                "or specify a project directory with the -g argument." % gmc_args.gmc_project_path)
+
+    # Some args for MPF we'll borrow as well
+    transferred_args = []
+    # TODO: Refactor the ArgParse to use subparsers
+    # and parent parsers to simplify the whole affair.
+    verbose_regex = r'-[\w]*[vV]'
+    if re.match(verbose_regex, " ".join(mpf_args)):
+        transferred_args.append("-v")
+
+    #pylint: disable-msg=consider-using-with
+    subprocess.Popen(
+        [full_godot_exec_path, *transferred_args],
+        cwd=gmc_args.gmc_project_path
+    )
+
+
+class Command:
+
+    """Command which runs game and gmc."""
+
+    def __init__(self, mpf_path, machine_path, args):
+        """Run game and gmc."""
+        # First load a config file for possible default values
+        config = configparser.ConfigParser(strict=False, allow_no_value=True)
+        try:
+            # It feels cleaner to use the same config file as GMC, even though the
+            # name is misleading
+            config_path = os.path.join(machine_path, "gmc.cfg")
+            os.stat(config_path)
+            config.read(config_path)
+        except FileNotFoundError:
+            pass
+
+        parser = argparse.ArgumentParser(description='Starts MPF and GMC concurrently')
+
+        parser.add_argument("-g",
+                            action="store", dest="gmc_project_path",
+                            default=config.get("cli", "gmc_project_path", fallback=machine_path).strip('\'"'),
+                            help="Path to the GMC project folder, if not current directory.")
+
+        parser.add_argument("-G",
+                            action="store", dest="godot_exec_path",
+                            default=config.get("cli", "godot_exec_path", fallback="godot").strip('\'"'),
+                            help="Path to the Godot executable")
+
+        parser.add_argument("-L",
+                            action="store", dest="gmc_log_file",
+                            metavar='gmc_log_file',
+                            default=config.get("cli", "gmc_log_file", fallback=None),
+                            help=argparse.SUPPRESS)
+
+        # Parse the GMC-specific args and pass the leftovers to MPF
+        gmc_args, mpf_args = parser.parse_known_args(args)
+
+        _spawn_gmc(gmc_args, mpf_args)
+
+        _start_mpf(mpf_path, machine_path, mpf_args)

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/commands/game.py

@@ -140,17 +140,6 @@ class Command:
                                  "used for all"
                                  " devices")
 
-        # The following are just included for full compatibility with mc
-        # which is needed when using "mpf both".
-
-        parser.add_argument("-L",
-                            action="store", dest="mc_file_name",
-                            metavar='mc_file_name',
-                            default=None, help=argparse.SUPPRESS)
-
-        parser.add_argument("--no-sound",
-                            action="store_true", dest="no_sound", default=False)
-
         self.args = parser.parse_args(args)
         self.args.configfile = Util.string_to_event_list(self.args.configfile)
 

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/commands/init.py

@@ -7,6 +7,7 @@ import shutil
 SUBCOMMAND = True
 INITIAL_MODES = ("attract", "base")
 
+
 class Command:
 
     """Initializes an MPF project folder."""
@@ -33,7 +34,7 @@ class Command:
         print("MPF project initialization complete!")
 
     def generate_config_file(self):
-        # Create the config folder
+        """Create a config folder and default config.yaml file."""
         config_dir = os.path.join(self.path, "config")
         try:
             os.stat(config_dir)
@@ -48,13 +49,13 @@ class Command:
             shutil.copy2(base_config_file, config_file)
 
     def generate_mode_folder(self):
+        """Create mode folder and default mode subfolders."""
         mode_dir = os.path.join(self.path, "modes")
         try:
             os.stat(mode_dir)
         except FileNotFoundError:
             os.mkdir(mode_dir)
 
-
         for mode in INITIAL_MODES:
             mode_path = os.path.join(mode_dir, mode, "config")
             try:

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/config_players/plugin_player.py

@@ -1,5 +1,6 @@
 """Plugin config player."""
 from mpf.config_players.device_config_player import DeviceConfigPlayer
+from mpf.core.placeholder_manager import BaseTemplate, NativeTypeTemplate
 
 
 class PluginPlayer(DeviceConfigPlayer):
@@ -85,9 +86,19 @@ class PluginPlayer(DeviceConfigPlayer):
         # this play event won't be swallowed.
         if '_from_bcp' in kwargs:
             del kwargs['_from_bcp']
+        # If any templates need evaluating, do so *before* sending via BCP
+        eval_settings = {}
+        for s, settings_dict in settings.items():
+            for key, value in settings_dict.items():
+                if isinstance(value, (BaseTemplate, NativeTypeTemplate)):
+                    if s not in eval_settings:
+                        eval_settings[s] = settings_dict.copy()
+                    eval_settings[s][key] = value.evaluate(kwargs)
+
         self.machine.bcp.interface.bcp_trigger(
             name='{}_play'.format(self.show_section),
-            settings=settings, context=context, calling_context=calling_context,
+            settings={**settings, **eval_settings},
+            context=context, calling_context=calling_context,
             priority=priority, **kwargs)
 
     def clear_context(self, context):

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/config_spec.yaml

@@ -668,6 +668,7 @@ fast_exp_board:
     led_ports: list|subconfig(fast_led_port)|None
     led_fade_time: single|ms|0
     led_hz: single|float|30
+    ignore_led_errors: single|bool|false
 fast_breakout:
     port: single|enum(1,2,3)|
     model: single|str|
@@ -841,6 +842,7 @@ high_score:
     award_slide_display_time: single|ms|4s
     categories: dict|str:list|
     defaults: dict|str:list|None
+    filler_initials: list|str|None
     enter_initials_timeout: single|secs|20s
     reverse_sort: list|str|None
     reset_high_scores_events: list|event_handler|high_scores_reset,factory_reset
@@ -1117,6 +1119,7 @@ mpf:
     core_modules: ignore
     config_players: ignore
     device_modules: ignore
+    min_mpf_version: single|str|None
     plugins: ignore
     platforms: ignore
     paths: ignore
@@ -1697,7 +1700,7 @@ sound_player:
     pan: single|float_or_token|None
     loops: single|int_or_token|None
     priority: single|int_or_token|None
-    start_at: single|secs|None
+    start_at: single|template_secs|None
     fade_in: single|secs|None
     fade_out: single|secs|None
     about_to_finish_time: single|secs|-1

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/core/device_manager.py

@@ -301,8 +301,7 @@ class DeviceCollection(dict):
         self.machine.log.warning("Iterating device collections directly is deprecated and will be removed. "
                                  "Access by value(): device_collections[%s] -> device_collections['%s'].values()",
                                  self.name, self.name)
-        for item in self.values():
-            yield item
+        yield from self.values()
 
     def items_tagged(self, tag) -> List["Device"]:
         """Return of list of device objects which have a certain tag.

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/core/logging.py

@@ -160,12 +160,13 @@ class LogMixin:
         if error_no:
             error_slug = "Log-{}-{}".format(self.log.name if self.log else "", error_no)
             error_url = log_url.format(error_slug)
-        if error_no and context:
-            return "{} Context: {} Log Code: {} ({})".format(msg, context, error_slug, error_url)
+
+            if context:
+                return "{} Context: {} Log Code: {} ({})".format(msg, context, error_slug, error_url)
+            return "{} Log Code: {} ({})".format(msg, error_slug, error_url)
+
         if context:
             return "{} Context: {} ".format(msg, context)
-        if error_no:
-            return "{} Log Code: {} ({})".format(msg, error_slug, error_url)
 
         return msg
 

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/core/machine.py

@@ -6,6 +6,7 @@ import sys
 import threading
 from typing import Any, Callable, Dict, List, Set, Optional
 
+from packaging import version
 from pkg_resources import iter_entry_points
 
 from mpf._version import __version__
@@ -368,6 +369,16 @@ class MachineController(LogMixin):
         self.validate_machine_config_section('machine')
         self.validate_machine_config_section('game')
         self.validate_machine_config_section('mpf')
+        self._validate_version()
+
+    def _validate_version(self):
+        if not self.config['mpf']['min_mpf_version']:
+            return
+        min_version = version.parse(self.config['mpf']['min_mpf_version'])
+        mpf_version = version.parse(__version__)
+        if mpf_version < min_version:
+            raise AssertionError(f'MPF version mismatch. MPF version {mpf_version} found but game config '
+                                 f'requires at least {min_version} ')
 
     def validate_machine_config_section(self, section: str) -> None:
         """Validate a config section."""
@@ -685,7 +696,11 @@ class MachineController(LogMixin):
         if not self.initialize_mpf():
             return
 
-        self.info_log("Starting the main run loop.")
+        self.info_log("Starting the main run loop with active modes: %s",
+                      self.mode_controller.active_modes)
+        if not self.modes['attract'] in self.mode_controller.active_modes:
+            self.warning_log("Attract mode is not active, game will not be playable. "
+                             "Please check your attract mode configuration.")
         self._run_loop()
 
     def stop_with_exception(self, exception) -> None:

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/core/text_ui.py

@@ -351,8 +351,11 @@ class TextUi(MpfController):
         self._machine_widgets.append(Label("MACHINE VARIABLES"))
         self._machine_widgets.append(Divider())
         machine_vars = self.machine.variables.machine_vars
-        # If config defines explict vars to show, only show those. Otherwise, all
-        names = self.config.get('machine_vars', machine_vars.keys())
+        # If config defines explict vars to show, only show those.
+        # Otherwise, filter out the unhelpful defaults
+        names = self.config.get('machine_vars', [n for n in machine_vars.keys() if not (
+            n.startswith("audits") or n.startswith("platform") or n.startswith("mpf"))
+        ])
         for name in names:
             self._machine_widgets.append(Label("{}: {}".format(name, machine_vars[name]['value'])))
         self._layout_change = True

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/core/utility_functions.py

@@ -185,8 +185,7 @@ class Util:
         """Convert a list of nested lists and/or values into a single one-dimensional list."""
         for item in incoming_list:
             if isinstance(item, IterableCollection) and not isinstance(item, str):
-                for inner_item in Util.flatten_list(item):
-                    yield inner_item
+                yield from Util.flatten_list(item)
             else:
                 yield item
 

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/devices/timer.py

@@ -144,8 +144,8 @@ class Timer(ModeDevice):
     def _setup_control_events(self, event_list):
         self.debug_log("Setting up control events")
 
-        kwargs = {}
         for entry in event_list:
+            kwargs = {}
             if entry['action'] in ('add', 'subtract', 'jump', 'pause', 'set_tick_interval'):
                 handler = getattr(self, entry['action'])
                 kwargs = {'timer_value': entry['value']}

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/modes/attract/code/attract.py

@@ -1,9 +1,9 @@
 """Contains the Attract class which is the attract mode in a pinball machine."""
 
-from mpf.core.mode import Mode
+from mpf.modes.carousel.code.carousel import Carousel
 
 
-class Attract(Mode):
+class Attract(Carousel):
 
     """Default mode running in a machine when a game is not in progress.
 
@@ -22,6 +22,13 @@ class Attract(Mode):
         self.start_hold_time = 0.0
         self.start_buttons_held = list()
 
+    def mode_init(self):
+        """Initialize the mode and handle missing carousel items."""
+        try:
+            super().mode_init()
+        except AssertionError:
+            pass
+
     def mode_start(self, **kwargs):
         """Start the attract mode."""
         # register switch handlers for the start button press so we can
@@ -50,6 +57,10 @@ class Attract(Mode):
                 playfield.ball_search.enable()
                 playfield.ball_search.start()
 
+        # Check for carousel items
+        if self._all_items:
+            super().mode_start(**kwargs)
+
     def start_button_pressed(self):
         """Handle start button press.
 

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/modes/bonus/code/bonus.py

@@ -95,29 +95,28 @@ class Bonus(Mode):
         # following names are reserved for end-of-bonus behavior.
         assert entry not in ["subtotal", "multiplier", "total"], "Bonus entry cannot be reserved word '%s'" % entry
 
-        # Calling player.vars.get() instead of player.get() bypasses the
-        # auto-fill zero and will throw if there is no player variable.
-        # The fallback value of 1 is used for bonus entries that don't use
-        # a player score, which are multiplied by one to get the bonus.
-        hits = self.player.vars.get(entry['player_score_entry'], 1)
+        # If a player_score_entry is provided, use player getattr to get a
+        # fallback value of zero if the variable is not set. Otherwise
+        # use 1 as the multiplier for non-player-score bonuses.
+        hits = self.player[entry['player_score_entry']] if entry['player_score_entry'] else 1
         score = entry['score'].evaluate([]) * hits
 
         if (not score and entry['skip_if_zero']) or (score < 0 and entry['skip_if_negative']):
-            self.debug_log("Skipping bonus entry '%s' because its value is 0",
-                           entry['entry'])
+            self.info_log("Skipping bonus entry '%s' because its value is 0",
+                          entry['entry'])
             self._bonus_next_item()
             return
 
         # pylint: disable=superfluous-parens
         if self.settings["rounding_value"] and (r := (score % self.settings["rounding_value"])):
-            self.debug_log("rounding bonus score %s remainder of %s", score, r)
+            self.info_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 '%s': score: %s player_score_entry: %s=%s",
-                       entry['entry'], score, entry['player_score_entry'], hits)
+        self.info_log("Bonus Entry '%s': score: %s player_score_entry: %s=%s",
+                      entry['entry'], score, entry['player_score_entry'], hits)
 
         self.bonus_score += score
         self.machine.events.post("bonus_entry", entry=entry['entry'],

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/modes/high_score/code/high_score.py

@@ -1,5 +1,6 @@
 """Contains the High Score mode code."""
 import asyncio
+from random import choice
 
 from mpf.core.async_mode import AsyncMode
 from mpf.core.player import Player
@@ -195,7 +196,8 @@ class HighScore(AsyncMode):
                     # ask player for initials if we do not know them
                     if not player.initials:
                         try:
-                            player.initials = await self._ask_player_for_initials(player, award_names[i], value)
+                            player.initials = await self._ask_player_for_initials(player, award_names[i],
+                                                                                  value, category_name)
                         except asyncio.TimeoutError:
                             del new_list[i]
                             # no entry when the player missed the timeout
@@ -241,7 +243,7 @@ class HighScore(AsyncMode):
         return var_dict
 
     # pylint: disable-msg=too-many-arguments
-    async def _ask_player_for_initials(self, player: Player, award_label: str, value: int) -> str:
+    async def _ask_player_for_initials(self, player: Player, award_label: str, value: int, category_name: str) -> str:
         """Show text widget to ask player for initials."""
         self.info_log("New high score. Player: %s, award_label: %s"
                       ", Value: %s", player, award_label, value)
@@ -256,8 +258,20 @@ class HighScore(AsyncMode):
             timeout=self.high_score_config['enter_initials_timeout']
         )   # type: dict
 
-        return event_result["text"] if "text" in event_result else ''
+        input_initials = event_result["text"] if "text" in event_result else ''
 
+        # If no initials were input, some can be randomly chosen from the 'filler_initials' config section
+        if not input_initials and self.high_score_config["filler_initials"]:
+            # High scores are stored as an array of [name, score]
+            existing_initials = [n[0] for n in self.high_scores[category_name]]
+            unused_initials = [i for i in self.high_score_config["filler_initials"] if i not in existing_initials]
+            # If there aren't enough to choose something unique, just pick any from the fillers
+            if not unused_initials:
+                unused_initials = self.high_score_config["filler_initials"]
+            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-0.80.0.dev6/mpf/modes/high_score/config/high_score.yaml

@@ -0,0 +1,54 @@
+#config_version=6
+mode:
+  code: mpf.modes.high_score.code.high_score.HighScore
+  priority: 1500
+  start_events: game_ending, start_high_score
+  game_mode: False
+  use_wait_queue: true
+
+# Instructions on how to use this mode:
+# https://missionpinball.org/game_logic/high_scores
+
+high_score:
+  enter_initials_timeout: 60
+  award_slide_display_time: 4s
+  categories:
+    score:
+      - GRAND CHAMPION
+      - HIGH SCORE 1
+      - HIGH SCORE 2
+      - HIGH SCORE 3
+      - HIGH SCORE 4
+  defaults:
+    score:
+      - BRI: 4242
+      - GHK: 2323
+      - JK: 1337
+      - QC: 42
+      - MPF: 23
+
+slide_player:
+  high_score_enter_initials:
+    high_score:
+        action: play
+  #   high_score_award_display:
+  #       action: remove
+  #   #Make sure to remove any slides you add under this high_score_enter_initials slide, or it will continue to
+  #   #show the award slide instead of initials for another player that also earned a high score.
+  #   score_award_display:
+  #       action: remove
+  # high_score_award_display:
+  #   high_score_award_display:
+  #       action: play
+  #   high_score_enter_initials:
+  #       action: remove
+  # #This is used to show the slide for a specific award and show additional parameters.  This can include any
+  # #static lables as well as dynamic player and machine variables.
+  # #You will need to generate this block again and swap the name for any subsequent categories that you want
+  # #to show unique additional values.
+  # score_award_display:
+  #   score_award_display:
+  #       action: play
+  #       priority: 1
+  #   high_score_enter_initials:
+  #       action: remove

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/modes/service/code/service.py

@@ -405,6 +405,7 @@ sort_devices_by_number: single|bool|True
         for board, l in items:
             numbers = l.get_hw_numbers()
             chain_2 = None
+            addr_2 = None
             # Just choose the first one as representative?
             number = numbers[0]
             if "-" in number:
@@ -454,9 +455,10 @@ sort_devices_by_number: single|bool|True
                 items.append(LightChainMap(platform_name, chain_name, chain))
         # do not crash if no lights are configured
         if not items:   # pragma: no cover
-            return
+            return []
 
         items.sort(key=lambda x: x.chain)
+        return items
 
     async def _volume_menu(self, platform=None):
         position = 0

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/fast/communicators/base.py

@@ -448,9 +448,9 @@ class FastSerialCommunicator(LogMixin):
                 if self.pause_sending_flag.is_set():
                     await self.pause_sending_flag.wait()
 
+            # TODO better way to catch shutting down?
             except SerialException as e:
                 self.log.error(e)
-                return  # TODO better way to catch shutting down?
 
     def write_to_port(self, msg, log_msg=None):
         """Send a message as is, without encoding or adding a <CR> character."""
@@ -464,4 +464,3 @@ class FastSerialCommunicator(LogMixin):
             self.writer.write(msg)
         except AttributeError:
             self.log.warning("Serial connection is not open. Cannot send message: %s", msg)
-            return

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/fast/communicators/net_neuron.py

@@ -293,7 +293,7 @@ class FastNetNeuronCommunicator(FastSerialCommunicator):
         This will silently sync the switch.hw_state. If the logical state changes,
         it will process it like any switch change.
         """
-        for switch in self.machine.switches:
+        for switch in [sw for sw in self.machine.switches.values() if sw.platform == self.platform]:
             hw_state = self.platform.hw_switch_data[switch.hw_switch.number]
 
             if hw_state != switch.hw_state:

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/fast/fast_driver.py

@@ -503,6 +503,9 @@ class FASTDriver:
             reconfigured = True
 
         if hold_settings is not None:
+            hold_power = Util.float_to_pwm8_hex_string(hold_settings.power)
+            hold_ms = "00"
+
             if hold_settings.duration > 25500:
                 raise AssertionError("FAST platform does not support hold durations > 25500ms")
             if 25500 >= hold_settings.duration > 255:
@@ -512,8 +515,6 @@ class FASTDriver:
                 hold_ms = Util.int_to_hex_string(hold_settings.duration)
                 mode = '10'
 
-            hold_power = Util.float_to_pwm8_hex_string(hold_settings.power)
-
         else:
             hold_ms = self.current_driver_config.param3
             hold_power = self.current_driver_config.param4

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/fast/fast_exp_board.py

@@ -2,6 +2,7 @@
 
 import asyncio
 from base64 import b16decode
+from binascii import Error as binasciiError
 from importlib import import_module
 
 from packaging import version
@@ -176,11 +177,12 @@ class FastExpansionBoard:
 
                 try:
                     self.communicator.send_bytes(b16decode(f'{msg_header}{msg}'), log_msg)
-                except Exception as e:
+                except binasciiError as e:
                     self.log.error(
                         f"Error decoding the following message for board {breakout_address} : {msg_header}{msg}")
-                    self.log.debug("Attempted update that caused this error: %s", dirty_leds)
-                    raise e
+                    self.log.info("Attempted update that caused this error: %s", dirty_leds)
+                    if not self.config['ignore_led_errors']:
+                        raise e
 
     def set_led_fade(self, rate: int) -> None:
         """Set LED fade rate in ms."""

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/light_segment_displays.py

@@ -2,7 +2,7 @@
 import logging
 
 from mpf.devices.segment_display.segment_display_text import ColoredSegmentDisplayText
-from mpf.core.segment_mappings import SEVEN_SEGMENTS, BCD_SEGMENTS, FOURTEEN_SEGMENTS, SIXTEEN_SEGMENTS,\
+from mpf.core.segment_mappings import SEVEN_SEGMENTS, BCD_SEGMENTS, FOURTEEN_SEGMENTS, SIXTEEN_SEGMENTS, \
     EIGHT_SEGMENTS, TextToSegmentMapper
 from mpf.platforms.interfaces.segment_display_platform_interface import SegmentDisplaySoftwareFlashPlatformInterface
 from mpf.core.platform import SegmentDisplaySoftwareFlashPlatform

{mpf-0.80.0.dev4 → mpf-0.80.0.dev6}/mpf/platforms/opp/opp.py

@@ -890,7 +890,6 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             ]
 
         self.raise_config_error("Unknown subtype {}".format(subtype), 8)
-        return []
 
     def configure_light(self, number, subtype, config, platform_settings):
         """Configure a led or matrix light."""
@@ -949,7 +948,6 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             return self.opp_incands[index].configure_software_fade_incand(light_num)
 
         self.raise_config_error("Unknown subtype {}".format(subtype), 12)
-        return None
 
     async def _poll_sender(self, chain_serial):
         """Poll switches."""
@@ -1148,6 +1146,7 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
         """Generate an OPPServo class with the given number."""
         del config
         chain_serial, _, pin_number = number.split('-')  # Unused value is 'card'
+        possible_inputs = None
 
         if self.min_version[chain_serial] < 0x02020002:
             self.raise_config_error("Servos not supported on this OPP FW version: {}.".format(
@@ -1157,7 +1156,7 @@ class OppHardwarePlatform(LightsPlatform, SwitchPlatform, DriverPlatform, ServoP
             if inputs.chain_serial == chain_serial:
                 possible_inputs = self._get_numbers(inputs.mask)
 
-        if 8 <= int(pin_number) < 16 and int(pin_number) in possible_inputs:
+        if 8 <= int(pin_number) < 16 and possible_inputs and int(pin_number) in possible_inputs:
             servo_number = int(pin_number) - 8
         else:
             self.raise_config_error("Servo unavailable at this number: {}.".format(number), 24)