mpf 0.58.0.dev4__py3-none-any.whl → 0.58.0.dev7__py3-none-any.whl

mpf/_version.py

@@ -10,7 +10,7 @@ PyPI.
 
 """
 
-__version__ = '0.58.0.dev4'  # Also consider whether MPF-MC pyproject.toml should be updated
+__version__ = '0.58.0.dev7'  # Also consider whether MPF-MC pyproject.toml should be updated
 '''The full version of MPF.'''
 
 __short_version__ = '0.58'

mpf/config_spec.yaml

@@ -1271,6 +1271,7 @@ pin2dmd:
     resolution: single|enum(128x32,192x64,256x64)|128x32
     panel: single|enum(rgb,rbg)|rgb
 pkone:
+    lightshow_groups: dict|str:str|None
     __valid_in__: machine
     __type__: config
     port: single|str|
@@ -1663,6 +1664,7 @@ state_machines:
     states: dict|str:subconfig(state_machine_states)|
     transitions: list|subconfig(state_machine_transitions)|
     persist_state: single|bool|false
+    repost_start_events_on_restore: single|bool|false
     starting_state: single|str|start
 state_machine_transitions:
     source: list|str|
@@ -1673,6 +1675,7 @@ state_machine_states:
     label: single|str|None
     show_when_active: single|subconfig(show_config)|None
     events_when_started: list|event_posted|None
+    events_when_restored: list|event_posted|None
     events_when_stopped: list|event_posted|None
 show_config:
     show: single|str|

mpf/core/logging.py

@@ -95,7 +95,9 @@ class LogMixin:
         if not self.log:
             self._logging_not_configured()
 
-        if self._debug_to_console:
+        if self._debug_to_console and self._debug_to_file:
+            level = 10
+        elif self._debug_to_console:
             level = 12
         elif self._debug_to_file:
             level = 11
@@ -116,7 +118,9 @@ class LogMixin:
         if not self.log:
             self._logging_not_configured()
 
-        if self._info_to_console or self._debug_to_console:
+        if (self._info_to_console or self._debug_to_console) and (self._info_to_file or self._debug_to_file):
+            level = 20
+        elif self._info_to_console or self._debug_to_console:
             level = 22
         elif self._info_to_file or self._debug_to_file:
             level = 21

mpf/devices/state_machine.py

@@ -83,9 +83,7 @@ class StateMachine(SystemWideDevice, ModeDevice):
         if not self.state:
             self._start_state(self.config['starting_state'])
         else:
-            self._add_handlers_for_current_state()
-            self._run_show_for_current_state()
-            self.notify_virtual_change("state", None, self.state)
+            self._restore_state(self.state)
 
     def device_removed_from_mode(self, mode: Mode):
         """Unset internal state to prevent leakage."""
@@ -128,6 +126,22 @@ class StateMachine(SystemWideDevice, ModeDevice):
         self._add_handlers_for_current_state()
         self._run_show_for_current_state()
 
+    def _restore_state(self, state):
+        self.debug_log("Restoring state %s", state)
+
+        state_config = self.config['states'][state]
+        if state_config['events_when_restored']:
+            for event_name in state_config['events_when_restored']:
+                self.machine.events.post(event_name)
+
+        elif self.config['repost_start_events_on_restore'] and state_config['events_when_started']:
+            for event_name in state_config['events_when_started']:
+                self.machine.events.post(event_name)
+
+        self._add_handlers_for_current_state()
+        self._run_show_for_current_state()
+        self.notify_virtual_change("state", None, self.state)
+
     def _run_show_for_current_state(self):
         assert not self._show
         state_config = self.config['states'][self.state]

mpf/mpfconfig.yaml

@@ -161,7 +161,7 @@ logging:
       data_manager: none  # todo subclasses
       delay_manager: none
       device_manager: none
-      event_manager: none
+      event_manager: basic
       extra_balls: none
       file_manager: none  # todo
       light_controller: none

mpf/platforms/pkone/pkone.py

@@ -5,33 +5,37 @@ Contains the hardware interface and drivers for the Penny K Pinball PKONE
 platform hardware.
 """
 import asyncio
+import re
 from copy import deepcopy
 from typing import Optional, Dict, List, Tuple, Set
 
+from mpf.core.platform import (
+    SwitchPlatform, DriverPlatform, LightsPlatform, SwitchSettings, DriverSettings,
+    DriverConfig, SwitchConfig, RepulseSettings, ServoPlatform)
 from mpf.core.platform_batch_light_system import PlatformBatchLightSystem
 from mpf.platforms.pkone.pkone_serial_communicator import PKONESerialCommunicator
-from mpf.platforms.pkone.pkone_extension import PKONEExtensionBoard
+from mpf.platforms.pkone.pkone_ex2 import PKONEEX2Board
 from mpf.platforms.pkone.pkone_lightshow import PKONELightshowBoard
-from mpf.platforms.pkone.pkone_switch import PKONESwitch, PKONESwitchNumber
+from mpf.platforms.pkone.pkone_switch import PKONESwitch, PKONESwitchNumber, PKONESwitchBoard
 from mpf.platforms.pkone.pkone_coil import PKONECoil, PKONECoilNumber
 from mpf.platforms.pkone.pkone_servo import PKONEServo, PKONEServoNumber
 from mpf.platforms.pkone.pkone_lights import PKONESimpleLED, PKONESimpleLEDNumber, PKONELEDChannel
 
-from mpf.core.platform import SwitchPlatform, DriverPlatform, LightsPlatform, SwitchSettings, DriverSettings, \
-    DriverConfig, SwitchConfig, RepulseSettings, ServoPlatform
+DUPLICATE_ADDRESS_ERROR = "Duplicate address id: a board has already been registered at address {}"
 
 
 # pylint: disable-msg=too-many-instance-attributes,too-many-public-methods
 class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, ServoPlatform):
 
-    """Platform class for the PKONE Nano hardware controller.
+    """Platform class for PKONE EX2, Switch and Lightshow hardware.
 
     Args:
     ----
         machine: The MachineController instance.
     """
 
-    __slots__ = ["config", "serial_connections", "pkone_extensions", "pkone_lightshows", "_light_system",
+    __slots__ = ["config", "serial_connections", "pkone_ex2_boards", "pkone_switch_boards",
+                 "pkone_lightshows", "_light_system",
                  "_watchdog_task", "hw_switch_data", "controller_connection", "pkone_commands"]
 
     def __init__(self, machine) -> None:
@@ -39,21 +43,27 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         super().__init__(machine)
         self.controller_connection = None
         self.serial_connections = set()     # type: Set[PKONESerialCommunicator]
-        self.pkone_extensions = {}          # type: Dict[int, PKONEExtensionBoard]
+        self.pkone_ex2_boards = {}          # type: Dict[int, PKONEEX2Board]
+        self.pkone_switch_boards = {}       # type: Dict[int, PKONESwitchBoard]
         self.pkone_lightshows = {}          # type: Dict[int, PKONELightshowBoard]
         self._light_system = None           # type: Optional[PlatformBatchLightSystem]
         self._watchdog_task = None
         self.hw_switch_data = dict()
 
-        self.pkone_commands = {'PCN': lambda x, y: None,            # connected Nano processor
-                               'PCB': lambda x, y: None,            # connected board
-                               'PWD': lambda x, y: None,            # watchdog
-                               'PWF': lambda x, y: None,            # watchdog stop
+        self.pkone_commands = {'PCN': lambda payload: None,            # connected USB controller
+                               'PCB': lambda payload: None,            # connected board
+                               'PWD': lambda payload: None,            # watchdog
+                               'PWT': self.receive_watchdog_timeout,
+                               'PWF': lambda payload: None,            # watchdog stop
                                'PSA': self.receive_all_switches,    # all switch states
                                'PSW': self.receive_switch,          # switch state change
                                'PXX': self.receive_error,           # error
                                }
 
+        for command in ('PRS', 'PWS', 'PCC', 'PCP', 'PCH', 'PCR', 'PHR', 'PHD', 'PSC',
+                        'PLS', 'PLO', 'PLB', 'PWB', 'PLW', 'PWW', 'PLC', 'PWC'):
+            self.pkone_commands[command] = lambda payload: None
+
         # Set platform features. Each platform interface can change
         # these to notify the framework of the specific features it supports.
         self.features['max_pulse'] = 250
@@ -65,7 +75,7 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         self.debug_log("Configuring PKONE hardware.")
 
     async def initialize(self):
-        """Initialize connection to PKONE Nano hardware."""
+        """Initialize the connection to PKONE hardware."""
         await self._connect_to_hardware()
 
         # Setup the batch light system
@@ -123,23 +133,40 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         infos += "------------------------\n"
         infos += " - Connected Controllers:\n"
         for connection in sorted(self.serial_connections, key=lambda x: x.port):
-            infos += "   -> PKONE Nano - Port: {} at {} baud " \
+            infos += "   -> PKONE EX2 USB connection - Port: {} at {} baud " \
                      "(firmware v{}, hardware rev {}).\n".format(connection.port,
                                                                  connection.baud,
                                                                  connection.remote_firmware,
                                                                  connection.remote_hardware_rev)
 
-        infos += "\n - Extension boards:\n"
-        for extension in self.pkone_extensions.values():
-            infos += "   -> Address ID: {} (firmware v{}, hardware rev {})\n".format(extension.addr,
-                                                                                     extension.firmware_version,
-                                                                                     extension.hardware_rev)
+        infos += "\n - EX2 boards:\n"
+        for board in self.pkone_ex2_boards.values():
+            infos += (
+                "   -> Address ID: {} (firmware v{}, hardware rev {})\n".format(
+                    board.addr,
+                    board.firmware_version,
+                    board.hardware_rev)
+            )
+
+        infos += "\n - Switch boards:\n"
+        for board in self.pkone_switch_boards.values():
+            infos += (
+                "   -> Address ID: {} (firmware v{}, hardware rev {})\n".format(
+                    board.addr,
+                    board.firmware_version,
+                    board.hardware_rev)
+            )
 
         infos += "\n - Lightshow boards:\n"
         for lightshow in self.pkone_lightshows.values():
+            firmware_type = 'RGB'
+            if lightshow.mixed_firmware:
+                firmware_type = 'MIX'
+            elif lightshow.rgbw_firmware:
+                firmware_type = 'RGBW'
             infos += "   -> Address ID: {} ({} firmware v{}, " \
                      "hardware rev {})\n".format(lightshow.addr,
-                                                 'RGBW' if lightshow.rgbw_firmware else 'RGB',
+                                                 firmware_type,
                                                  lightshow.firmware_version,
                                                  lightshow.hardware_rev)
 
@@ -151,22 +178,32 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         await comm.connect()
         self.serial_connections.add(comm)
 
-    def register_extension_board(self, board: PKONEExtensionBoard):
-        """Register an Extension board."""
-        if board.addr in self.pkone_extensions or board.addr in self.pkone_lightshows:
-            raise AssertionError("Duplicate address id: a board has already been "
-                                 "registered at address {}".format(board.addr))
+    def _address_is_registered(self, address):
+        return (address in self.pkone_ex2_boards or address in self.pkone_switch_boards or
+                address in self.pkone_lightshows)
+
+    def register_ex2_board(self, board: PKONEEX2Board):
+        """Register an EX2 board."""
+        if self._address_is_registered(board.addr):
+            raise AssertionError(DUPLICATE_ADDRESS_ERROR.format(board.addr))
 
         if board.addr not in range(8):
-            raise AssertionError("Address out of range: Extension board address id must be between 0 and 7")
+            raise AssertionError("Address out of range: EX2 board address id must be between 0 and 7")
 
-        self.pkone_extensions[board.addr] = board
+        self.pkone_ex2_boards[board.addr] = board
+
+    def register_switch_board(self, board: PKONESwitchBoard):
+        """Register a Switch board."""
+        if self._address_is_registered(board.addr):
+            raise AssertionError(DUPLICATE_ADDRESS_ERROR.format(board.addr))
+        if board.addr not in range(8):
+            raise AssertionError("Address out of range: Switch board address id must be between 0 and 7")
+        self.pkone_switch_boards[board.addr] = board
 
     def register_lightshow_board(self, board: PKONELightshowBoard):
         """Register a Lightshow board."""
-        if board.addr in self.pkone_extensions or board.addr in self.pkone_lightshows:
-            raise AssertionError("Duplicate address id: a board has already been "
-                                 "registered at address {}".format(board.addr))
+        if self._address_is_registered(board.addr):
+            raise AssertionError(DUPLICATE_ADDRESS_ERROR.format(board.addr))
 
         if board.addr not in range(4):
             raise AssertionError("Address out of range: Lightshow board address id must be between 0 and 3")
@@ -182,7 +219,7 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         """
         assert self.log is not None
         cmd = msg[0:3]
-        payload = msg[3:].replace('E', '')
+        payload = msg[3:].removesuffix('E')
 
         # Can't use try since it swallows too many errors for now
         if cmd in self.pkone_commands:
@@ -190,6 +227,12 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         else:   # pragma: no cover
             self.log.warning("Received unknown serial command %s.", msg)
 
+    def receive_watchdog_timeout(self, msg):
+        """Stop play when the controller reports that host communication was lost."""
+        del msg
+        self.machine.stop(
+            "PKONE hardware watchdog expired; outputs were disabled. Restart after checking the connection.")
+
     def receive_error(self, msg):
         """Receive an error message from the controller."""
         self.log.error("Received an error message from the controller: %s", msg)
@@ -203,16 +246,16 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         board_id = int(board_id_str)
         coil_num = int(coil_num_str)
 
-        if board_id not in self.pkone_extensions:
-            raise AssertionError("PKONE Extension {} does not exist for coil {}".format(board_id, number))
+        if board_id not in self.pkone_ex2_boards:
+            raise AssertionError("PKONE EX2 {} does not exist for coil {}".format(board_id, number))
 
         if coil_num == 0:
             raise AssertionError("PKONE coil numbering begins with 1. Coil: {}".format(number))
 
-        coil_count = self.pkone_extensions[board_id].coil_count
+        coil_count = self.pkone_ex2_boards[board_id].coil_count
         if coil_count < coil_num or coil_num < 1:
             raise AssertionError(
-                "PKONE Extension {board_id} only has {coil_count} coils "
+                "PKONE EX2 {board_id} only has {coil_count} coils "
                 "({first_coil} - {last_coil}). Coil: {number}".format(
                     board_id=board_id, coil_count=coil_count, first_coil=1, last_coil=coil_count, number=number))
 
@@ -245,7 +288,7 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
     @staticmethod
     def _check_coil_switch_combination(coil: DriverSettings, switch: SwitchSettings):
         """Check to see if the coil/switch combination is legal for hardware rules."""
-        # coil and switch must be on the same extension board (same board address id)
+        # A hardware rule requires both devices on the same EX2 address.
         if switch.hw_switch.number.board_address_id != coil.hw_driver.number.board_address_id:
             raise AssertionError("Coil {} and switch {} are on different boards. Cannot apply hardware rule!".format(
                 coil.hw_driver.number, switch.hw_switch.number))
@@ -346,14 +389,14 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         board_id = int(board_id_str)
         servo_num = int(servo_num_str)
 
-        if board_id not in self.pkone_extensions:
-            raise AssertionError("PKONE Extension {} does not exist for servo {}".format(board_id, number))
+        if board_id not in self.pkone_ex2_boards:
+            raise AssertionError("PKONE EX2 {} does not exist for servo {}".format(board_id, number))
 
         # Servos are numbered in sequence immediately after the highest coil number
-        driver_count = self.pkone_extensions[board_id].coil_count
-        servo_count = self.pkone_extensions[board_id].servo_count
+        driver_count = self.pkone_ex2_boards[board_id].coil_count
+        servo_count = self.pkone_ex2_boards[board_id].servo_count
         if servo_num <= driver_count or servo_num > driver_count + servo_count:
-            raise AssertionError("PKONE Extension {} supports {} servos ({} - {}). "
+            raise AssertionError("PKONE EX2 {} supports {} servos ({} - {}). "
                                  "Servo: {} is not a valid number.".format(
                                      board_id, servo_count, driver_count + 1, driver_count + servo_count, number))
 
@@ -379,15 +422,16 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         board_id = int(board_id_str)
         switch_num = int(switch_num_str)
 
-        if board_id not in self.pkone_extensions:
-            raise AssertionError("PKONE Extension {} does not exist for switch {}".format(board_id, number))
+        board = self.pkone_ex2_boards.get(board_id) or self.pkone_switch_boards.get(board_id)
+        if board is None:
+            raise AssertionError("PKONE input board {} does not exist for switch {}".format(board_id, number))
 
         if switch_num == 0:
             raise AssertionError("PKONE switch numbering begins with 1. Switch: {}".format(number))
 
-        if self.pkone_extensions[board_id].switch_count < switch_num:
-            raise AssertionError("PKONE Extension {} only has {} switches. Switch: {}".format(
-                board_id, self.pkone_extensions[board_id].switch_count, number))
+        if board.switch_count < switch_num:
+            raise AssertionError("PKONE board {} only has {} switch inputs. Switch: {}".format(
+                board_id, board.switch_count, number))
 
         return PKONESwitchNumber(board_id, switch_num)
 
@@ -430,9 +474,12 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         # [PSA opcode] + [[board address id] + 0 or 1 for each switch on the board] + E
         self.debug_log("Received all switch states (PSA): %s", msg)
 
-        # the message payload is delimited with an 'X' character for the switches on each board
-        # The first character is the board address ID
+        if not msg or msg[0] not in '01234567':
+            raise AssertionError("Invalid PKONE switch snapshot: {}".format(msg))
         board_address_id = int(msg[0])
+        board = self.pkone_ex2_boards.get(board_address_id) or self.pkone_switch_boards.get(board_address_id)
+        if board is None or not re.fullmatch('[01]{' + str(board.switch_count) + '}', msg[1:]):
+            raise AssertionError("Invalid PKONE switch snapshot: {}".format(msg))
         switch_states = msg[1:]
 
         # There is one character for each switch on the board (1 = active, 0 = inactive)
@@ -446,8 +493,14 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         # The PSW message contains the following information:
         # [PSW opcode] + [board address id] + switch number + switch state (0 or 1) + E
         self.debug_log("Received switch state change (PSW): %s", msg)
-        switch_number = PKONESwitchNumber(int(msg[0]), int(msg[1:3]))
-        switch_state = int(msg[-1])
+        if not re.fullmatch(r'[0-7][0-9]{2}[01]', msg):
+            raise AssertionError("Invalid PKONE switch event: {}".format(msg))
+        board_id, number, switch_state = int(msg[0]), int(msg[1:3]), int(msg[3])
+        board = self.pkone_ex2_boards.get(board_id) or self.pkone_switch_boards.get(board_id)
+        if board is None or not 1 <= number <= board.switch_count:
+            raise AssertionError("Unknown PKONE switch: {}".format(msg))
+        switch_number = PKONESwitchNumber(board_id, number)
+        self.hw_switch_data[switch_number] = switch_state
         self.machine.switch_controller.process_switch_by_num(state=switch_state,
                                                              num=switch_number,
                                                              platform=self)
@@ -461,7 +514,7 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
 
         # get the lightshow board that will be sent the command (need to know if rgb or rgbw board)
         lightshow = self.pkone_lightshows[first_channel.board_address_id]
-        if lightshow.rgbw_firmware:
+        if lightshow.channels_for_group(first_channel.group) == 4:
             cmd_opcode = "PWB"
             channel_grouping = 4
         else:
@@ -546,6 +599,9 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
             board_address_id, group, index = number.split("-")
             led_channel = PKONELEDChannel(board_address_id, group, index, config, self._light_system)
             lightshow = self.pkone_lightshows[int(board_address_id)]
+            channels = lightshow.channels_for_group(group)
+            if not 0 <= int(index) < 64 * channels:
+                raise AssertionError("PKONE LED channel exceeds this group's 64-pixel range")
             lightshow.add_channel_hw_driver(int(group), led_channel)
             self._light_system.mark_dirty(led_channel)
             return led_channel
@@ -556,9 +612,9 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
         """Determine whether the specified LED is hardware aligned."""
         light = self.machine.lights[led_name]
         hw_numbers = light.get_hw_numbers()
-        board_address_id, _, index = hw_numbers[0].split("-")
+        board_address_id, group, index = hw_numbers[0].split("-")
         lightshow = self.pkone_lightshows[int(board_address_id)]
-        if lightshow.rgbw_firmware:
+        if lightshow.channels_for_group(group) == 4:
             channel_grouping = 4
         else:
             channel_grouping = 3
@@ -589,7 +645,7 @@ class PKONEHardwarePlatform(SwitchPlatform, DriverPlatform, LightsPlatform, Serv
             index = int(number_str)
 
             # Determine if there are 3 or 4 channels depending upon firmware on board
-            if self.pkone_lightshows[board_address_id].rgbw_firmware:
+            if self.pkone_lightshows[int(board_address_id)].channels_for_group(group) == 4:
                 # rgbw uses 4 channels per led
                 return [
                     {

mpf/platforms/pkone/pkone_coil.py

@@ -16,7 +16,7 @@ PKONECoilConfiguration = namedtuple("PKONECoilConfiguration", ["pulse_settings",
 
 class PKONECoil(DriverPlatformInterface):
 
-    """Base class for coils/drivers connected to a PKONE Controller/Extension."""
+    """A coil/driver connected to a PKONE EX2 board."""
 
     __slots__ = ["log", "hardware_rule", "_config_state", "machine", "platform",
                  "send", "platform_settings"]
@@ -37,10 +37,10 @@ class PKONECoil(DriverPlatformInterface):
         self.reset()
 
     def get_board_name(self):
-        """Return PKONE Extension addr."""
-        if self.number.board_address_id not in self.platform.pkone_extensions.keys():
+        """Return PKONE EX2 address."""
+        if self.number.board_address_id not in self.platform.pkone_ex2_boards:
             return "PKONE Unknown Board"
-        return "PKONE Extension Board {}".format(self.number.board_address_id)
+        return "PKONE EX2 Board {}".format(self.number.board_address_id)
 
     def get_recycle_time_ms_for_cmd(self, recycle, pulse_ms) -> int:
         """Return recycle ms."""

mpf/platforms/pkone/{pkone_extension.py → pkone_ex2.py}

@@ -1,29 +1,29 @@
-"""PKONE Extension board."""
+"""PKONE EX2 board."""
 import logging
 
 
 # pylint: disable-msg=too-few-public-methods
-class PKONEExtensionBoard:
+class PKONEEX2Board:
 
-    """PKONE Extension board."""
+    """PKONE EX2 board with switches, optos, coils and servos."""
 
     __slots__ = ["log", "addr", "firmware_version", "hardware_rev", "switch_count",
                  "coil_count", "servo_count"]
 
     def __init__(self, addr, firmware_version, hardware_rev):
-        """Initialize PKONE Extension board."""
-        self.log = logging.getLogger('PKONEExtensionBoard {}'.format(addr))
+        """Initialize a PKONE EX2 board."""
+        self.log = logging.getLogger('PKONEEX2Board {}'.format(addr))
         self.addr = addr
         self.firmware_version = firmware_version
         self.hardware_rev = hardware_rev
-        self.switch_count = 35  # numbers 1 - 35 (31-35 are NC opto switches)
-        self.coil_count = 10  # numbers 1 - 10
-        self.servo_count = 4    # numbers 11-14
+        self.switch_count = 35  # inputs 1-30 are switches; 31-35 are optos
+        self.coil_count = 10  # outputs 1-10
+        self.servo_count = 4  # outputs 11-14
 
     def get_description_string(self) -> str:
         """Return description string."""
-        return "PKONE Extension Board {} - Firmware: {}, Hardware Rev: {}, " \
-               "Switches: {}, Coils: {}, Servos: {}".format(
+        return "PKONE EX2 Board {} - Firmware: {}, Hardware Rev: {}, " \
+               "Switches/Optos: {}, Coils: {}, Servos: {}".format(
                    self.addr,
                    self.firmware_version,
                    self.hardware_rev,

mpf/platforms/pkone/pkone_lights.py

@@ -17,7 +17,7 @@ PKONESimpleLEDNumber = namedtuple("PKONESimpleLEDNumber", ["board_address_id", "
 
 class PKONESimpleLED(LightPlatformSoftwareFade):
 
-    """A simple led (single emitter/color) on a PKONE Extension board. Simple leds are either on or off."""
+    """A general-lighting output on a PKONE Lightshow board."""
 
     __slots__ = ["log", "send", "platform"]
 
@@ -46,7 +46,7 @@ class PKONESimpleLED(LightPlatformSoftwareFade):
 
     def get_board_name(self):
         """Return PKONE Lightshow addr."""
-        if self.number.board_address_id not in self.platform.pkone_extensions.keys():
+        if self.number.board_address_id not in self.platform.pkone_lightshows:
             return "PKONE Unknown Board"
         return "PKONE Lightshow Board {}".format(self.number.board_address_id)
 

mpf/platforms/pkone/pkone_lightshow.py

@@ -11,15 +11,17 @@ class PKONELightshowBoard:
     """PKONE Lightshow board."""
 
     __slots__ = ["log", "addr", "firmware_version", "hardware_rev", "rgbw_firmware", "simple_led_count", "led_groups",
-                 "max_leds_per_group", "_channel_hw_drivers"]
+                 "max_leds_per_group", "_channel_hw_drivers", "mixed_firmware", "group_types"]
 
     # pylint: disable-msg=too-many-arguments
-    def __init__(self, addr, firmware_version, hardware_rev, rgbw_firmware=False):
+    def __init__(self, addr, firmware_version, hardware_rev, rgbw_firmware=False, mixed_firmware=False):
         """Initialize PKONE Lightshow board."""
         self.log = logging.getLogger('PKONELightshowBoard {}'.format(addr))
         self.addr = addr
         self.firmware_version = firmware_version
         self.rgbw_firmware = rgbw_firmware
+        self.mixed_firmware = mixed_firmware
+        self.group_types = {}
         self.hardware_rev = hardware_rev
         self.simple_led_count = 40  # numbers 1 - 40
         self.led_groups = 8  # numbers 1 - 8
@@ -29,8 +31,23 @@ class PKONELightshowBoard:
         for group in range(1, self.led_groups + 1):
             self._channel_hw_drivers[group] = {}
 
+    def channels_for_group(self, group):
+        """Return the configured wire width; never guess for a mixed board."""
+        group = int(group)
+        if not 1 <= group <= 8:
+            raise AssertionError("PKONE LED group must be 1-8")
+        if not self.mixed_firmware:
+            return 4 if self.rgbw_firmware else 3
+        if group not in self.group_types:
+            raise AssertionError(f"Configure pkone: lightshow_groups: '{self.addr}-{group}' as rgb or rgbw")
+        return self.group_types[group]
+
     def get_description_string(self) -> str:
         """Return description string."""
+        if self.mixed_firmware:
+            return (f"PKONE Lightshow Board {self.addr} - mixed RGB/RGBW firmware: "
+                    f"{self.firmware_version}, Hardware Rev: {self.hardware_rev}, "
+                    f"configured groups: {self.group_types}")
         if self.rgbw_firmware:
             return "PKONE Lightshow Board {} - RGBW Firmware: {}, Hardware Rev: {}, Simple LEDs: {}, " \
                    "RGBW LED Groups: {} (max {} LEDs per RGBW group)".format(self.addr,