mpf 0.57.0.dev37__tar.gz → 0.57.0.dev39__tar.gz

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.0.dev37
+Version: 0.57.0.dev39
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT
@@ -33,7 +33,6 @@ Requires-Dist: pyserial-asyncio==0.6
 Requires-Dist: ruamel.yaml==0.17.32
 Requires-Dist: sortedcontainers==2.4.0
 Requires-Dist: terminaltables==3.1.10
-Requires-Dist: uvloop==0.17.0; platform_system != "Windows"
 Requires-Dist: Pillow==9.5.0
 Provides-Extra: crash-reporter
 Requires-Dist: requests==2.28.2; extra == "crash-reporter"

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/_version.py

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

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/devices/ball_device/ball_count_handler.py

@@ -93,7 +93,7 @@ class BallCountHandler(BallDeviceStateHandler):
 
         self._ball_count = await self.counter.count_balls()
         # on start try to reorder balls if count is unstable
-        if self.counter.is_count_unreliable():
+        if self.counter.is_count_unreliable() or self.counter.is_jammed():
             self.info_log("BCH: Count is unstable. Trying to reorder balls.")
             await self.ball_device.ejector.reorder_balls()
             self.info_log("BCH: Repulse done. Waiting for balls to settle.")

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/devices/driver.py

@@ -382,6 +382,8 @@ class Driver(SystemWideDevice):
         # Let the PSU wait for both the pulse _and_ the timed enable
         wait_ms = self._notify_psu_and_get_wait_ms(pulse_duration + hold_duration, max_wait_ms)
 
+        self.info_log("Pulsing Driver for %sms (%s pulse_power) with timed enable for %sms (%s hold_power)",
+                      pulse_duration, pulse_power, hold_duration, hold_power)
         # TODO: Detect a NotImplementedError and simulate a timed_enable
         #       with a software timer and enable+disable
         self.hw_driver.timed_enable(PulseSettings(pulse_power, pulse_duration),

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/devices/drop_target.py

@@ -60,7 +60,7 @@ class DropTarget(SystemWideDevice):
             self.config['playfield'].ball_search.register(
                 self.config['ball_search_order'], self._ball_search, self.name)
 
-        if '{}_active'.format(self.config['playfield'].name) in self.config['switch'].tags:
+        if f"{self.config['playfield'].name}_active" in self.config['switch'].tags:
             self.raise_config_error(
                 "Drop target device '{}' uses switch '{}' which has a "
                 "'{}_active' tag. This is handled internally by the device. Remove the "
@@ -214,7 +214,10 @@ class DropTarget(SystemWideDevice):
         is_complete = self.machine.switch_controller.is_active(
             self.config['switch'])
 
+        self.debug_log("Drop target %s switch %s has active value %s compared to drop complete %s",
+                       self.name, self.config['switch'].name, is_complete, self.complete)
         if self._in_ball_search or self._ignore_switch_hits:
+            self.debug_log("Ignoring state change in drop target %s due to being in ball search or ignoring switch hits", self.name)
             return
 
         if not reconcile:

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/devices/state_machine.py

@@ -100,7 +100,7 @@ class StateMachine(SystemWideDevice, ModeDevice):
             self._show = None
 
     def _stop_current_state(self):
-        self.log.debug("Stopping state %s", self.state)
+        self.debug_log("Stopping state %s", self.state)
         self._remove_handlers()
         state_config = self.config['states'][self.state]
         if state_config['events_when_stopped']:
@@ -108,14 +108,14 @@ class StateMachine(SystemWideDevice, ModeDevice):
                 self.machine.events.post(event_name)
 
         if self._show:
-            self.log.debug("Stopping show %s", self._show)
+            self.debug_log("Stopping show %s", self._show)
             self._show.stop()
             self._show = None
 
         self.state = None
 
     def _start_state(self, state):
-        self.log.debug("Starting state %s", state)
+        self.debug_log("Starting state %s", state)
         if state not in self.config['states']:
             raise AssertionError("Invalid state {}".format(state))
 
@@ -132,7 +132,7 @@ class StateMachine(SystemWideDevice, ModeDevice):
         assert not self._show
         state_config = self.config['states'][self.state]
         if state_config['show_when_active']:
-            self.log.debug("Starting show %s", state_config['show_when_active'])
+            self.debug_log("Starting show %s", state_config['show_when_active'])
             self._show = self.machine.show_controller.play_show_with_config(state_config['show_when_active'],
                                                                             self.mode)
 
@@ -145,7 +145,7 @@ class StateMachine(SystemWideDevice, ModeDevice):
 
     def _transition(self, transition_config, **kwargs):
         del kwargs
-        self.log.info("Transitioning from %s to %s", self.state, transition_config["target"])
+        self.info_log("Transitioning from %s to %s", self.state, transition_config["target"])
         self._stop_current_state()
         if transition_config['events_when_transitioning']:
             for event_name in transition_config['events_when_transitioning']:

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/modes/service/code/service.py

@@ -11,7 +11,7 @@ from mpf.core.switch_controller import MonitoredSwitchChange
 from mpf.core.utility_functions import Util
 
 ServiceMenuEntry = namedtuple("ServiceMenuEntry", ["label", "callback"])
-
+LightChainMap = namedtuple("LightMap", ["board", "chain", "light"])
 
 class Service(AsyncMode):
 
@@ -167,6 +167,7 @@ sort_devices_by_number: single|bool|True
         """Return the light menu items with label and callback."""
         return [
             ServiceMenuEntry("Single Light Test", self._light_test_menu),
+            ServiceMenuEntry("Light Chain Test", self._light_chain_menu)
         ]
 
     async def _diagnostics_light_menu(self):
@@ -420,6 +421,15 @@ sort_devices_by_number: single|bool|True
                                  light_num=light.config['number'],
                                  test_color=color)
 
+    def _update_light_chain_slide(self, items, position, color):
+        board, chain, lights = items[position]
+        self.machine.events.post("service_light_test_start",
+                                 board_name=board,
+                                 light_name=" ",
+                                 light_label=chain,
+                                 light_num=" ",
+                                 test_color=color)
+
     async def _light_test_menu(self):
         position = 0
         color_position = 0
@@ -456,6 +466,96 @@ sort_devices_by_number: single|bool|True
 
         self.machine.events.post("service_light_test_stop")
 
+    async def _light_chain_menu(self):
+        position = 0
+        color_position = 0
+        colors = ["white", "red", "green", "blue", "yellow"]
+        items = self.machine.service.get_light_map(do_sort=self._do_sort)
+
+        # Categorize by platform and address
+        chain_lookup = {}
+        for board, l in items:
+            numbers = l.get_hw_numbers()
+            chain_2 = None
+            # Just choose the first one as representative?
+            number = numbers[0]
+            if "-" in number:
+                bits = number.split("-")  # e.g. led-7-4-r
+                if len(bits) == 2:
+                    # FAST lights are single addresses in blocks of 64
+                    if board.startswith("FAST"):
+                        addr = int(bits[0], 16)
+                        chain = addr // 64
+                    else:
+                        chain, addr = bits
+                elif len(bits) == 3:
+                    chain, addr, color = bits
+                elif len(bits) == 4:
+                    _, chain, addr, color = bits
+                else:
+                    self.warning_log("Unknown bits in parsing light address: %s", bits)
+                    continue
+                chain = f"Chain {chain}"
+            elif l.config['subtype'] == "matrix":
+                # Matrix lights get two chains: one for the row, one for the column
+                number = int(number, 16)
+                chain = f"Row {(number // 8) + 1}"
+                addr = number % 8
+                chain_2 = f"Column {(number % 8) + 1}"
+                addr_2 = number // 8
+            else:
+                chain = "XX"
+                addr = number
+
+            for platform in l.platforms:
+                platform_name = type(platform).__name__
+                if platform_name not in chain_lookup:
+                    chain_lookup[platform_name] = {}
+                if not chain in chain_lookup[platform_name]:
+                    chain_lookup[platform_name][chain] = []
+                chain_lookup[platform_name][chain].append((addr, l))
+                # This is ugly, but is iteration overkill?
+                if chain_2:
+                    if not chain_2 in chain_lookup[platform_name]:
+                        chain_lookup[platform_name][chain_2] = []
+                    chain_lookup[platform_name][chain_2].append((addr_2, l))
+
+        items = []
+        for platform_name, chains in chain_lookup.items():
+            for chain_name, chain in chains.items():
+                items.append(LightChainMap(platform_name, chain_name, chain))
+        # do not crash if no lights are configured
+        if not items:   # pragma: no cover
+            return
+
+        items.sort(key=lambda x: x.chain )
+
+        while True:
+            self._update_light_chain_slide(items, position, colors[color_position])
+            for addr, l in items[position].light:
+                l.color(colors[color_position], key="service", priority=1000000)
+
+            key = await self._get_key()
+            for addr, l in items[position].light:
+                l.remove_from_stack_by_key("service")
+            if key == 'ESC':
+                break
+            if key == 'UP':
+                position += 1
+                if position >= len(items):
+                    position = 0
+            elif key == 'DOWN':
+                position -= 1
+                if position < 0:
+                    position = len(items) - 1
+            elif key == 'ENTER':
+                # change color
+                color_position += 1
+                if color_position >= len(colors):
+                    color_position = 0
+
+        self.machine.events.post("service_light_test_stop")
+
     async def _volume_menu(self, platform=None):
         position = 0
         if platform:

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/communicators/base.py

@@ -60,7 +60,7 @@ class FastSerialCommunicator(LogMixin):
         else:
             self.watchdog_cmd = None
 
-        self.configure_logging(logger=f'[{self.remote_processor}]', console_level=config['debug'],
+        self.configure_logging(logger=f'FAST [{self.remote_processor}]', console_level=config['debug'],
                                file_level=config['debug'], url_base='https://fastpinball.com/mpf/error')
                                 # TODO change these to not be hardcoded
                                 # TODO do something with the URL endpoint
@@ -349,10 +349,14 @@ class FastSerialCommunicator(LogMixin):
             self.no_response_waiting.set()
 
         # if the msg_header matches the first chars of the self.pause_sending_until, unpause sending
+        # Note that the msg_header includes the colon (e.g. "DL:", "SA:") and therefore
+        # pause_sending_until must also include the colon.
         if self.pause_sending_flag.is_set() and self.pause_sending_until.startswith(msg_header):
             self._resume_sending()
 
     def pause_sending(self, msg_header):
+        if __debug__:
+            assert len(msg_header) >= 3, f"Confirmation headers should be at least three characters, received '{msg_header}'"
         self.pause_sending_until = msg_header
         self.pause_sending_flag.set()
 
@@ -409,7 +413,8 @@ class FastSerialCommunicator(LogMixin):
                 if self.pause_sending_flag.is_set():
                     await self.pause_sending_flag.wait()
 
-            except:
+            except Exception as e:
+                self.log.error(e)
                 return  # TODO better way to catch shutting down?
 
     def write_to_port(self, msg, log_msg=None):

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/communicators/net_neuron.py

@@ -116,7 +116,7 @@ class FastNetNeuronCommunicator(FastSerialCommunicator):
 
         # self.drivers contains a list of all drivers, not just ones defined in the config
         for driver in self.drivers:
-            await self.send_and_wait_for_response_processed(f'{self.DRIVER_CMD}:{Util.int_to_hex_string(driver.number)}', self.DRIVER_CMD)
+            await self.send_and_wait_for_response_processed(f'{self.DRIVER_CMD}:{Util.int_to_hex_string(driver.number)}', f"{self.DRIVER_CMD}:")
 
         self.platform.drivers_initialized = True
 

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/fast.py

@@ -79,8 +79,10 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
         else:
             self.raise_config_error(f'Unknown machine_type "{self.machine_type}" configured fast.', 6)
 
+        # Even though System11 uses ticks, that's handled on the Overlay and not needed here.
+        self.features['tickless'] = True
         # Most FAST platforms don't use ticks, but System11 does
-        self.features['tickless'] = self.machine_type != 'sys11'
+        #self.features['tickless'] = self.machine_type != 'sys11'
         self.features['max_pulse'] = 25500
 
         self.serial_connections = dict()

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/fast_defines.py

@@ -12,6 +12,7 @@ USB_IDS = {  # (VID, PID)
     (11914, 4156): ('aud', 'FAST Audio Interface'),
     (11914, 4157): ('exp', 'FAST Expansion Board'),
     (11914, 4158): ('dsp', 'FAST Display Controller'),
+    (5824, 1163):  ('net', 'FAST Retro Controller'),  # Teensyduino
     (1027, 24593): ('net', 'FAST Nano Controller'),  # FTDI Quad RS232-HS
 }
 

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/fast_driver.py

@@ -31,7 +31,7 @@ class FASTDriver:
     """Base class for drivers connected to a FAST Controller."""
 
     __slots__ = ["log", "communicator", "number", "hw_number", "autofire_config", "baseline_driver_config",
-                 "current_driver_config", "mode_param_mapping", "platform_settings"]
+                 "config", "current_driver_config", "mode_param_mapping", "platform_settings"]
 
     def __init__(self, communicator: FastSerialCommunicator, hw_number: int) -> None:
         """Initialize the driver object.
@@ -42,6 +42,7 @@ class FASTDriver:
         self.communicator = communicator
         self.number = hw_number  # must be int to work with the rest of MPF
         self.hw_number = Util.int_to_hex_string(hw_number)  # hex version the FAST hw actually uses
+        self.config = None
         self.autofire_config = None
         self.platform_settings = dict()
 
@@ -56,6 +57,7 @@ class FASTDriver:
             '12': ['pwm1_ms', 'pwm1_power', 'pwm2_ms', 'pwm2_power', 'kick_ms'],
             '18': ['pwm1_ms', 'pwm1_power', 'pwm2_power', 'recycle_ms', None],
             '20': ['off_switch', 'pwm1_ms', 'pwm1_power', 'pwm2_power', 'rest_ms'],
+            '25': ['relay_on_report_ms', 'relay_off_report_ms'],
             '30': ['delay_ms_x10', 'pwm1_ms', 'pwm2_ms', 'pwm2_power', 'recycle_ms'],
             '70': ['pwm1_ms', 'pwm1_power', 'pwm2_ms_x100', 'pwm2_power', 'recycle_ms'],
             '75': ['off_switch', 'pwm1_ms', 'pwm2_ms_x100', 'pwm2_power', 'recycle_ms'],
@@ -73,7 +75,7 @@ class FASTDriver:
 
         This will not be called for drivers that are not in the MPF config.
         """
-
+        self.config = mpf_config
         self.platform_settings = platform_settings
         self.current_driver_config = self.convert_mpf_config_to_fast(mpf_config, platform_settings)
         self.baseline_driver_config = copy(self.current_driver_config)
@@ -144,8 +146,8 @@ class FASTDriver:
         return Util.int_to_hex_string(num)
 
     def send_config_to_driver(self, one_shot: bool = False, wait_to_confirm: bool = False):
-        self.log.debug("Sending config to driver %s. one_shot: %s. wait_to_confirm: %s",
-                       self.number, one_shot, wait_to_confirm)
+        self.log.debug("Sending config to driver %s (0x%s). one_shot: %s. wait_to_confirm: %s",
+                       self.number, self.hw_number, one_shot, wait_to_confirm)
 
         if one_shot:
             trigger = self.set_bit(self.current_driver_config.trigger, 3)
@@ -157,7 +159,7 @@ class FASTDriver:
                f'{self.current_driver_config.param2},{self.current_driver_config.param3},{self.current_driver_config.param4},'
                f'{self.current_driver_config.param5}')
         if wait_to_confirm:
-            self.communicator.send_with_confirmation(msg, f'{self.communicator.DRIVER_CMD}')
+            self.communicator.send_with_confirmation(msg, f'{self.communicator.DRIVER_CMD}:')
         else:
             self.communicator.send_and_forget(msg)
 
@@ -354,17 +356,38 @@ class FASTDriver:
         self.autofire_config = None
         self.communicator.send_and_forget(f'{self.communicator.TRIGGER_CMD}:{self.hw_number},02')
 
+    def set_relay(self, relay_switch, debounce_closed_ms, debounce_open_ms):
+        """Set an AC Relay rule with virtual switch."""
+
+        self.log.debug("Setting A/C Relay for driver %s (0x%s) and switch %s (0x%s)",
+                       self.number, self.hw_number, relay_switch.number, relay_switch.hw_number)
+        self.current_driver_config = FastDriverConfig(number=self.hw_number, trigger='81',
+                                        switch_id=relay_switch.hw_number,
+                                        mode='25',
+                                        param1=Util.int_to_hex_string(debounce_closed_ms),
+                                        param2=Util.int_to_hex_string(debounce_open_ms),
+                                        param3='00',
+                                        param4='00',
+                                        param5='00')
+        self.send_config_to_driver(wait_to_confirm=True)
+
     def enable(self, pulse_settings: PulseSettings, hold_settings: HoldSettings):
         """Enable (turn on) this driver."""
 
-        self.log.debug("Enabling (turning on) driver %s with pulse_settings: %s and hold_settings: %s.",
-                       self.number, pulse_settings, hold_settings)
+        self.log.debug("Enabling (turning on) driver %s (0x%s) mode %s with pulse_settings: %s and hold_settings: %s.",
+                       self.number, self.hw_number, self.current_driver_config.mode, pulse_settings, hold_settings)
 
         self._check_and_clear_delay()
 
         reconfigured = False
         mode = self.current_driver_config.mode
 
+        # AC Relays have special behavior
+        if mode == '25':
+            self.log.debug(" - A/C Relay activating!")
+            self.communicator.send_and_forget(f'{self.communicator.TRIGGER_CMD}:{self.hw_number},03')
+            return
+
         pwm1_ms = Util.int_to_hex_string(pulse_settings.duration)
         pwm1_power = Util.float_to_pwm8_hex_string(pulse_settings.power)
         pwm2_power = Util.float_to_pwm8_hex_string(hold_settings.power)

{mpf-0.57.0.dev37 → mpf-0.57.0.dev39}/mpf/platforms/fast/fast_port_detector.py

@@ -70,18 +70,14 @@ class FastPortDetector:
 
             total_attempts = 5
             attempts = 0
-            while True:
+            while attempts < total_attempts:
                 writer.write(b'ID:\r')
 
                 # Wait for a response with 1-second timeout
                 try:
                     data = await asyncio.wait_for(reader.read(100), timeout=1.0)
                 except asyncio.TimeoutError:
-                    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)
+                    pass
 
                 if data:
                     data = data.decode('utf-8', errors='ignore')
@@ -91,6 +87,9 @@ class FastPortDetector:
                             self._report_success(processor, port)
                             writer.close()
                             return
+                attempts += 1
+            self.platform.debug_log("Unable to get ID: on port %s after %s retries.", port, total_attempts)
+            return
 
     def _report_success(self, processor, port):
         self.results[processor] = port