mpf 0.57.0.dev27__tar.gz → 0.57.0.dev30__tar.gz

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mpf
-Version: 0.57.0.dev27
+Version: 0.57.0.dev30
 Summary: The Mission Pinball Framework (MPF)
 Author-email: The Mission Pinball Framework Team <brian@missionpinball.org>
 License: MIT

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/_version.py

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

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/devices/score_reel_controller.py

@@ -56,13 +56,13 @@ class ScoreReelController:
         self.machine.events.add_handler('player_score', self._score_change)
 
         # receives notifications of game starts to reset the reels
-        self.machine.events.add_handler('game_starting', self._game_starting)
+        self.machine.events.add_async_handler('game_starting', self._game_starting)
 
         # receives notifications of game ends to reset the reels
         self.machine.events.add_handler('game_ending', self._game_ending)
 
         # Need to hook this in case reels aren't done when ball ends
-        self.machine.events.add_handler('ball_ending', self._ball_ending, 900)
+        self.machine.events.add_async_handler('ball_ending', self._ball_ending, 900)
 
     def _rotate_player(self, **kwargs):
         """Start a new player's turn.
@@ -123,7 +123,7 @@ class ScoreReelController:
             # set value
             score_reel_group.set_value(value=value)
 
-    def _game_starting(self, queue, **kwargs):
+    async def _game_starting(self, **kwargs):
         """Reset the score reels when a new game starts.
 
         This is a queue event so it doesn't allow the game start to continue
@@ -134,8 +134,6 @@ class ScoreReelController:
             queue: A reference to the queue object for the game starting event.
         """
         del kwargs
-        # tell the game_starting event queue that we have stuff to do
-        queue.wait()
 
         # calculate a player <-> reel mapping
         for player_num in range(1, self.machine.game.max_players + 1):
@@ -156,17 +154,9 @@ class ScoreReelController:
         futures = []
         for score_reel_group in self.machine.score_reel_groups.values():
             score_reel_group.set_value(0)
-            futures.append(score_reel_group.wait_for_ready())
+            await score_reel_group.wait_for_ready()
 
-        future = asyncio.wait(iter(futures))
-        future = asyncio.ensure_future(future)
-        future.add_done_callback(partial(self._reels_ready, queue=queue))
-
-    @staticmethod
-    def _reels_ready(future, queue):
-        """Unblock queue since all reels are ready."""
-        del future
-        queue.clear()
+        await asyncio.gather(*futures)
 
     def _game_ending(self, **kwargs):
         """Reset controller."""
@@ -176,11 +166,8 @@ class ScoreReelController:
         self.active_scorereelgroup = None
         self.player_to_scorereel_map = {}
 
-    def _ball_ending(self, queue=None, **kwargs):
+    async def _ball_ending(self, **kwargs):
         del kwargs
-        # We need to hook the ball_ending event in case the ball ends while the
-        # score reel is still catching up.
-        queue.wait()
 
-        future = asyncio.ensure_future(self.active_scorereelgroup.wait_for_ready())
-        future.add_done_callback(partial(self._reels_ready, queue=queue))
+        for score_reel_group in self.machine.score_reel_groups.values():
+            await score_reel_group.wait_for_ready()

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/devices/score_reel_group.py

@@ -114,14 +114,10 @@ class ScoreReelGroup(SystemWideDevice):
 
             self.reels[i].set_destination_value(self.desired_value_list[i])
 
-    def wait_for_ready(self):
+    async def wait_for_ready(self):
         """Return a future which will be done when all reels reached their destination."""
-        futures = []
-        for reel in self.reels:
-            if reel:
-                futures.append(reel.wait_for_ready())
-
-        return asyncio.wait(iter(futures))
+        futures = [reel.wait_for_ready() for reel in self.reels if reel]
+        await asyncio.gather(*futures)
 
     def int_to_reel_list(self, value):
         """Convert an integer to a list of integers that represent each positional digit in this ScoreReelGroup.

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/TODO.md

@@ -4,7 +4,6 @@
 
 * Neuron, add support for delayed pulse (Mode 30). This should be added via a `platform_settings:` coil config entry, and then also should "just work" for autofire coils and/or with autofire overwrite rules.
 * Support next / previous for EXP LEDs
-* RGBW LEDs on EXP bus (Eli will add functionality to the EXP boards that will take RGB colors and convert them to RGBW, so all we'll have to add is a way to specify which LEDs are RGBW so we can send the correct config commands.)
 * Add ability to not probe the serial ports for platforms where the order does not change (e.g. everything but windows.) This will speed up the initial load time. (though only by about 100ms) We will still use the USB PID/VID to identify which serial ports are connected to which devices, we just won't actually probe them to verify their IDs.
 
 ## Things to verify / check / confirm
@@ -20,19 +19,17 @@
 
 ## Platform interfaces yet to update / add
 
-* Audio
 * Emulation (start / stop / what else?)
 * DMD
 * Segment displays v1 (move over existing functionality)
 * Segment displays v2 (switch to per-segment control and binary commands, full RGB support for different colors per segment, etc.)
-* PC Control (via the Neuron and Audio interface)
+* PC Control (via the Neuron)
 * Smart power control features (waiting on FAST to release firmware)
 
 ## Refactoring
 
 * Move FAST devices on EXP and breakout boards to mixin classes. e.g. LEds are a mixin class, servos are a mixin class, so the config for an EXP-0071 would pull in those two mixin classes rather than having device specific code in the base class.
 * Figure out the config file errors / error logs to FAST site / etc. Currently there is no consistency, need to figure out which errors we link to the web, come up with a template and URLs to display them, etc.
-* Single LED update task. Currently the LED update task is per EXP board which means they can be off by a few ms. We should have a single LED update task that runs at the same time for all boards.
 * Change EXP `led_hz` setting to `led_update_ms` or something (specify in ms and not hertz since that's how the hardware works. Also enforce multiples of 32ms since that's the hw update speed.)
 
 ## MPF general

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/aud.py

@@ -1,3 +1,5 @@
+# mpf/platforms/fast/communicators/aud.py
+
 from packaging import version
 
 from mpf.platforms.fast.communicators.base import FastSerialCommunicator

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/base.py

@@ -20,7 +20,7 @@ class FastSerialCommunicator(LogMixin):
     __slots__ = ["platform", "remote_processor", "config", "writer", "reader", "read_task", "received_msg", "log",
                  "machine", "fast_debug", "port_debug", "remote_firmware", "send_queue", "write_task",
                  "pause_sending_until", "pause_sending_flag", "no_response_waiting", "done_waiting",
-                 "ignore_decode_errors", "message_processors", "remote_model", "port"]
+                 "ignore_decode_errors", "message_processors", "remote_model", "port", "tasks", "watchdog_cmd"]
 
     def __init__(self, platform, processor, config):
         """Initialize FastSerialCommunicator."""
@@ -30,7 +30,9 @@ class FastSerialCommunicator(LogMixin):
         self.config = config
         self.writer = None
         self.reader = None
+        self.tasks = list()  # higher level tasks subclasses might need
         self.read_task = None
+        self.write_task = None
         self.received_msg = b''
         self.log = None
         self.machine = platform.machine
@@ -41,7 +43,7 @@ class FastSerialCommunicator(LogMixin):
         self.remote_firmware = None  # TODO some connections have more than one processor, should there be a processor object?
 
         self.send_queue = asyncio.Queue()  # Tuples of ( message, pause_until_string)
-        self.write_task = None
+
         self.pause_sending_until = ''
         self.pause_sending_flag = asyncio.Event()
         self.no_response_waiting = asyncio.Event()
@@ -53,6 +55,11 @@ class FastSerialCommunicator(LogMixin):
         self.message_processors = {'XX:': self._process_xx,
                                    'ID:': self._process_id}
 
+        if config.get('watchdog', None):
+            self.watchdog_cmd = f"WD:{config['watchdog']:02X}"
+        else:
+            self.watchdog_cmd = None
+
         self.configure_logging(logger=f'[{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
@@ -176,6 +183,15 @@ class FastSerialCommunicator(LogMixin):
                     self.log.info(f"<<<< {buffer}")
                 return buffer
 
+    def start_watchdog(self):
+        """Start listening for commands and schedule watchdog."""
+
+        if self.watchdog_cmd:
+            self._watchdog_task()  # send one now
+            self.tasks.append(self.machine.clock.schedule_interval(
+                self._watchdog_task,
+                self.config['watchdog'] / 2000))
+
     def start_tasks(self):
         """Start periodic tasks, etc.
 
@@ -188,6 +204,11 @@ class FastSerialCommunicator(LogMixin):
         to do things that need to go out before the connection is closed. A 100ms delay to allow for this happens after this is called."""
         pass
 
+    def cancel_tasks(self):
+        # called after stopping()
+        for task in self.tasks:
+            task.cancel()
+
     def stop(self):
         """Stop and shut down this serial connection."""
         self.log.debug("Stop called on serial connection %s", self.remote_processor)
@@ -334,6 +355,11 @@ class FastSerialCommunicator(LogMixin):
         self.pause_sending_until = None
         self.pause_sending_flag.clear()
 
+    def _watchdog_task(self):
+        """Sends the watchdog command."""
+
+        self.send_and_forget(self.watchdog_cmd)
+
     async def _socket_reader(self):
         # Read coroutine
         while True:

mpf-0.57.0.dev30/mpf/platforms/fast/communicators/dmd.py

@@ -0,0 +1,24 @@
+# mpf/platforms/fast/communicators/dmd.py
+
+from packaging import version
+
+from mpf.core.utility_functions import Util
+from mpf.platforms.fast.communicators.base import FastSerialCommunicator
+
+MIN_FW = version.parse('0.88') # override in subclass
+
+class FastRgbDmdCommunicator(FastSerialCommunicator):
+
+    """Handles the serial communication to a DMD in the FAST platform."""
+
+    IGNORED_MESSAGES = []
+
+    def send_frame(self, pixel_bytes): # todo is this meth even used?
+        self.send_bytes(b'BM:' + pixel_bytes, f'<{len(pixel_bytes)} bytes>')
+
+    async def init(self):
+        await self.send_and_wait_for_response_processed('ID:', 'ID:', max_retries=-1)  # Loop here until we get a response
+
+    async def soft_reset(self):
+        pixel_bytes = 128 * 32 * 3 * b'0'
+        self.send_frame(pixel_bytes)

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/emu.py

@@ -1,3 +1,5 @@
+# mpf/platforms/fast/communicators/emu.py
+
 from packaging import version
 
 from mpf.core.utility_functions import Util

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/exp.py

@@ -1,3 +1,5 @@
+# mpf/platforms/fast/communicators/exp.py
+
 from mpf.platforms.fast.fast_defines import EXPANSION_BOARD_FEATURES
 from mpf.platforms.fast.fast_exp_board import FastExpansionBoard
 from mpf.platforms.fast.communicators.base import FastSerialCommunicator
@@ -14,7 +16,7 @@ class FastExpCommunicator(FastSerialCommunicator):
 
     IGNORED_MESSAGES = ['XX:F']
 
-    __slots__ = ["exp_boards_by_address", "active_board", "_led_task"]
+    __slots__ = ["exp_boards_by_address", "active_board"]
 
     def __init__(self, platform, processor, config):
 
@@ -22,8 +24,6 @@ class FastExpCommunicator(FastSerialCommunicator):
 
         self.exp_boards_by_address = dict()  # keys = board addresses, values = FastExpansionBoard objects
         self.active_board = None
-        self._led_task = None
-
         self.message_processors['BR:'] = self._process_br
 
     async def init(self):
@@ -33,11 +33,12 @@ class FastExpCommunicator(FastSerialCommunicator):
         """Start listening for commands and schedule watchdog."""
 
         for board in self.exp_boards_by_address.values():
-            board.start_tasks()
+            self.tasks.append(self.platform.machine.clock.schedule_interval(
+                          board._update_leds, 1 / board.config['led_hz']))
 
     def stopping(self):
         for board in self.exp_boards_by_address.values():
-            board.stopping()
+            board.communicator.send_and_forget(f'BR@{board.address}:')
 
     async def soft_reset(self):
         for board in self.exp_boards_by_address.values():

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/net_neuron.py

@@ -24,16 +24,12 @@ class FastNetNeuronCommunicator(FastSerialCommunicator):
     DRIVER_CMD = 'DL'
     SWITCH_CMD = 'SL'
 
-    __slots__ = ["watchdog_cmd", "_watchdog_task", "io_loop", "switches", "drivers"]
+    __slots__ = ["io_loop", "switches", "drivers"]
 
     def __init__(self, platform, processor, config):
         super().__init__(platform, processor, config)
 
-        self.watchdog_cmd = f"WD:{config['watchdog']:02X}"
-        self._watchdog_task = None
-
         self.io_loop = [None] * len(self.config['io_loop'])
-
         self.switches = list()
         self.drivers = list()
 
@@ -320,19 +316,5 @@ class FastNetNeuronCommunicator(FastSerialCommunicator):
                                                              platform=self.platform,
                                                              logical=True)
 
-    def _update_watchdog(self):
-        """Send Watchdog command."""
-
-        self.send_and_forget(self.watchdog_cmd)
-
-    def start_tasks(self):
-        """Start listening for commands and schedule watchdog."""
-        self._update_watchdog()
-        self._watchdog_task = self.machine.clock.schedule_interval(self._update_watchdog,
-                                                                   self.config['watchdog'] / 2000)
-
     def stopping(self):
-        if self._watchdog_task:
-            self._watchdog_task.cancel()
-            self._watchdog_task = None
         self.send_and_forget('WD:1')

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/rgb.py

@@ -1,3 +1,5 @@
+# mpf/platforms/fast/communicators/rgb.py
+
 from packaging import version
 
 from mpf.core.utility_functions import Util
@@ -15,7 +17,6 @@ class FastRgbCommunicator(FastSerialCommunicator):
     def __init__(self, platform, processor, config):
         super().__init__(platform, processor, config)
 
-        self._led_task = None
         self.message_processors['!B:'] = self._process_boot_msg
 
     async def init(self):
@@ -52,8 +53,8 @@ class FastRgbCommunicator(FastSerialCommunicator):
         if self.config['led_hz'] > 30:
             self.config['led_hz'] = 30
 
-        self._led_task = self.machine.clock.schedule_interval(
-                        self.update_leds, 1 / self.config['led_hz'])
+        self.tasks.append(self.machine.clock.schedule_interval(
+                          self.update_leds, 1 / self.config['led_hz']))
 
     async def soft_reset(self, **kwargs):
         """Reset the NET processor."""
@@ -67,8 +68,4 @@ class FastRgbCommunicator(FastSerialCommunicator):
         # self.send_and_forget(f"RF:{Util.int_to_hex_string(self.config['led_fade_time'])}")
 
     def stopping(self):
-        if self._led_task:
-            self._led_task.cancel()
-            self._led_task = None
-
         self.reset()

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/communicators/seg.py

@@ -1,3 +1,5 @@
+# mpf/platforms/fast/communicators/seg.py
+
 from packaging import version
 
 from mpf.platforms.fast.communicators.base import FastSerialCommunicator
@@ -15,12 +17,9 @@ class FastSegCommunicator(FastSerialCommunicator):
     IGNORED_MESSAGES = []
 
     async def init(self):
-        await super().init()
-
-        self._seg_task = None
+        await self.send_and_wait_for_response_processed('ID:', 'ID:', max_retries=-1)  # Loop here until we get a response
 
     def start_tasks(self):
-        """Start the communicator."""
 
         for s in self.machine.device_manager.collections["segment_displays"]:
             self.platform.fast_segs.append(s.hw_display)
@@ -28,8 +27,8 @@ class FastSegCommunicator(FastSerialCommunicator):
         self.platform.fast_segs.sort(key=lambda x: x.number)
 
         if self.platform.fast_segs:
-            self._seg_task = self.machine.clock.schedule_interval(self._update_segs,
-                                                1 / self.config['fps'])
+            self.tasks.append(self.machine.clock.schedule_interval(self._update_segs,
+                              1 / self.config['fps']))
 
     def _update_segs(self, **kwargs):
         for s in self.platform.fast_segs:
@@ -42,26 +41,11 @@ class FastSegCommunicator(FastSerialCommunicator):
                 self.send_and_forget(('PC:{},{}').format(s.hex_id, s.next_color))
                 s.next_color = None
 
-    def _process_id(self, msg):
-        """Process the ID response."""
-
-        # No FW comparison as some have v 'FF.FF' We can fix this for real in the future if the
-        # firmware is changed in a way that matters for MPF.
-
-        # TODO make this actually check each display
-        self.remote_processor, self.remote_model, self.remote_firmware = msg.split()
-        self.platform.log.info(f"Connected to SEG processor on {self.remote_model} with firmware v{self.remote_firmware}")
-
     async def soft_reset(self):
         pass  # TODO turn off all segments
 
     def stopping(self):
-        if self._seg_task:
-            self._seg_task.cancel()
-            self._seg_task = None
-
-        # TODO Better way to do this?
         for s in self.platform.fast_segs:
-            self.send_and_forget(f'PA:{s.hex_id},        ')
+            self.send_and_forget(f'PA:{s.hex_id},')
             s.next_text = None
             s.next_color = None

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/fast.py

@@ -5,7 +5,7 @@ from typing import Dict, Optional
 
 from serial import SerialException
 
-from mpf.core.platform import (DmdPlatform, DriverConfig, DriverSettings,
+from mpf.core.platform import (RgbDmdPlatform, DriverConfig, DriverSettings,
                                LightsPlatform, RepulseSettings,
                                SegmentDisplayPlatform, ServoPlatform,
                                SwitchConfig, SwitchSettings)
@@ -30,7 +30,7 @@ from mpf.platforms.interfaces.light_platform_interface import LightPlatformInter
 from mpf.platforms.system11 import System11Driver, System11OverlayPlatform
 
 
-class FastHardwarePlatform(ServoPlatform, LightsPlatform, DmdPlatform,
+class FastHardwarePlatform(ServoPlatform, LightsPlatform, RgbDmdPlatform,
                            SegmentDisplayPlatform,
                            System11OverlayPlatform):
 
@@ -161,6 +161,7 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, DmdPlatform,
 
         for conn in self.serial_connections.values():
             conn.stopping()
+            conn.cancel_tasks()
 
         # wait 100ms for the messages to be sent
         if not self.unit_test:
@@ -176,6 +177,7 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, DmdPlatform,
     def _start_communicator_tasks(self, **kwargs):  # init_phase_3
         del kwargs
         for comm in self.serial_connections.values():
+            comm.start_watchdog()
             comm.start_tasks()
 
     def __repr__(self):
@@ -254,8 +256,8 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, DmdPlatform,
                 self.serial_connections['aud'] = communicator
             elif port == 'dmd':
                 from mpf.platforms.fast.communicators.dmd import \
-                    FastDmdCommunicator
-                communicator = FastDmdCommunicator(platform=self, processor=port,config=config)
+                    FastRgbDmdCommunicator
+                communicator = FastRgbDmdCommunicator(platform=self, processor=port,config=config)
                 self.serial_connections['dmd'] = communicator
             elif port == 'emu':
                 from mpf.platforms.fast.communicators.emu import \
@@ -696,14 +698,14 @@ class FastHardwarePlatform(ServoPlatform, LightsPlatform, DmdPlatform,
 
         raise AssertionError(f"Unknown LED subtype {subtype}")
 
-    def configure_dmd(self):
+    def configure_rgb_dmd(self, name):
         """Configure a hardware DMD connected to a FAST controller."""
         if not self.serial_connections['dmd']:
             raise AssertionError("A request was made to configure a FAST DMD, "
                                  "but no connection to a DMD processor is "
                                  "available.")
 
-        return FASTDMD(self.machine, self.serial_connections['dmd'].send_raw)
+        return FASTDMD(self.machine, name, self.serial_connections['dmd'])
 
     def configure_audio_interface(self):
         """Configure a hardware FAST audio controller."""

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/fast_dmd.py

@@ -6,13 +6,12 @@ class FASTDMD(DmdPlatformInterface):
 
     """Object for a FAST DMD."""
 
-    def __init__(self, machine, sender):
+    def __init__(self, machine, name, sender):
         """initialize DMD."""
         self.machine = machine
+        self.name = name
         self.send = sender
 
-        # Clear the DMD
-        # todo
 
     def set_brightness(self, brightness: float):
         """Set brightness."""
@@ -26,4 +25,5 @@ class FASTDMD(DmdPlatformInterface):
         ----
             data: bytes to send to DMD
         """
-        self.send_bytes(data)
+
+        self.send.send_frame(data)

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/platforms/fast/fast_exp_board.py

@@ -15,7 +15,7 @@ class FastExpansionBoard:
     """A FAST Expansion board on the EXP connection."""
 
     __slots__ = ["name", "communicator", "config", "platform", "log", "address", "model", "features", "breakouts",
-                 "breakouts_with_leds", "_led_task", "firmware_version", "hw_verified", "led_fade_rate"]
+                 "breakouts_with_leds", "firmware_version", "hw_verified", "led_fade_rate"]
 
     def __init__(self, name: str, communicator, address: str, config: dict) -> None:
         """Initializes a FAST Expansion Board
@@ -46,7 +46,9 @@ class FastExpansionBoard:
         self.features = EXPANSION_BOARD_FEATURES[self.model]  # ([local model numbers,], num of remotes) tuple
         self.breakouts = dict()
         self.breakouts_with_leds = list()
-        self._led_task = None  # TODO move to breakout or port and/or mixin class?
+
+        if self.config['led_hz'] > 31.25:
+            self.config['led_hz'] = 31.25
 
         # create the local breakouts
         for idx in range(len(self.features['local_breakouts'])):
@@ -124,22 +126,6 @@ class FastExpansionBoard:
             else:
                 self.hw_verified = True
 
-    def start_tasks(self):
-        self._update_leds()
-
-        if self.config['led_hz'] > 31.25:
-            self.config['led_hz'] = 31.25
-
-        self._led_task = self.platform.machine.clock.schedule_interval(
-                        self._update_leds, 1 / self.config['led_hz'])
-
-    def stopping(self):
-        if self._led_task:
-            self._led_task.cancel()
-            self._led_task = None
-
-        self.communicator.send_and_forget(f'BR@{self.address}:')
-
     async def reset(self):
         await self.communicator.send_and_wait_for_response_processed(f'BR@{self.address}:', 'BR:P')
 

{mpf-0.57.0.dev27 → mpf-0.57.0.dev30}/mpf/tests/machine_files/fast/config/audio.yaml

@@ -17,7 +17,7 @@ fast:
     max_hw_volume_headphones: 40
     link_sub_to_main: false
     link_headphones_to_main: false
-
+    watchdog: 0
     pin2_pulse_time: 99
     power_pulse_time: 98
     reset_pulse_time: 97

mpf-0.57.0.dev30/mpf/tests/machine_files/fast/config/dmd.yaml

@@ -0,0 +1,12 @@
+#config_version=6
+
+hardware:
+    platform: fast
+
+fast:
+  dmd:
+    port: com8
+
+rgb_dmds:
+  dmd:
+    label: Test

mpf-0.57.0.dev30/mpf/tests/machine_files/fast/config/seg.yaml

@@ -0,0 +1,25 @@
+#config_version=6
+
+hardware:
+    platform: fast
+
+fast:
+  seg:
+    port: com7
+
+segment_displays:
+    7_seg_display_1:
+        number: 0
+        size: 7
+    7_seg_display_2:
+        number: 1
+        size: 7
+    7_seg_display_3:
+        number: 2
+        size: 7
+    7_seg_display_4:
+        number: 3
+        size: 7
+    7_seg_display_5:
+        number: 4
+        size: 6