mx-remote 2.0.0__py3-none-any.whl

mx_remote/proto/Constants.py

@@ -0,0 +1,382 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+from enum import Enum
+from typing import Any
+
+MXR_PROTOCOL_VERSION = 20
+
+MXR_DEVICE_FEATURE_IR_RX              = (1 << 0)
+MXR_DEVICE_FEATURE_IR_TX              = (1 << 1)
+MXR_DEVICE_FEATURE_CEC                = (1 << 2)
+MXR_DEVICE_FEATURE_V2IP_SOURCE        = (1 << 3)
+MXR_DEVICE_FEATURE_V2IP_SINK          = (1 << 4)
+MXR_DEVICE_FEATURE_VIDEO_ROUTING      = (1 << 5)
+MXR_DEVICE_FEATURE_AUDIO_ROUTING      = (1 << 6)
+MXR_DEVICE_FEATURE_VOLUME_CONTROL     = (1 << 7)
+MXR_DEVICE_FEATURE_AUDIO_RETURN       = (1 << 8)
+MXR_DEVICE_FEATURE_REMOTE_CONTROL     = (1 << 9)
+MXR_DEVICE_FEATURE_SETUP_COMPLETED    = (1 << 10)
+MXR_DEVICE_FEATURE_MESH_MASTER        = (1 << 11)
+MXR_DEVICE_FEATURE_STATUS_NOTIFY      = (1 << 12)
+MXR_DEVICE_FEATURE_STATUS_WARNING     = (1 << 13)
+MXR_DEVICE_FEATURE_STATUS_ERROR       = (1 << 14)
+MXR_DEVICE_FEATURE_STATUS_REBOOTING   = (1 << 15)
+MXR_DEVICE_FEATURE_MESH_MEMBER        = (1 << 16)
+MXR_DEVICE_FEATURE_AUDIO_AMPLIFIER    = (1 << 17)
+MXR_DEVICE_FEATURE_BOOTING            = (1 << 18)
+MXR_DEVICE_FEATURE_MANAGER            = (1 << 19)
+MXR_DEVICE_FEATURE_BOOT_BIT           = (1 << 31)
+
+MX_BAY_FEATURE_HDMI_OUT           = (1 << 0)
+MX_BAY_FEATURE_HDMI_IN            = (1 << 1)
+MX_BAY_FEATURE_AUDIO_DIG_OUT      = (1 << 2)
+MX_BAY_FEATURE_AUDIO_DIG_IN       = (1 << 3)
+MX_BAY_FEATURE_AUDIO_ANA_OUT      = (1 << 4)
+MX_BAY_FEATURE_AUDIO_ANA_IN       = (1 << 5)
+MX_BAY_FEATURE_IR_IN              = (1 << 6)
+MX_BAY_FEATURE_IR_OUT             = (1 << 7)
+MX_BAY_FEATURE_AUDIO_AMP_OUT      = (1 << 8)
+MX_BAY_FEATURE_RC_OUT             = (1 << 9)
+MX_BAY_FEATURE_RC_IN              = (1 << 10)
+MX_BAY_FEATURE_DOLBY              = (1 << 11)
+MX_BAY_FEATURE_AUTO_OFF           = (1 << 12)
+MX_BAY_FEATURE_V2IP_SOURCE_REMOTE = (1 << 13)
+MX_BAY_FEATURE_V2IP_SINK_REMOTE   = (1 << 14)
+MX_BAY_FEATURE_V2IP_SOURCE_LOCAL  = (1 << 15)
+MX_BAY_FEATURE_V2IP_SINK_LOCAL    = (1 << 16)
+MX_BAY_FEATURE_DOLBY_IN_POS       = 24
+
+MX_LINK_FEATURE_NONE          = 0
+MX_LINK_FEATURE_VIDEO_HDMI    = (1 << 0)
+MX_LINK_FEATURE_AUDIO_OPTICAL = (1 << 1)
+MX_LINK_FEATURE_AUDIO_ANALOG  = (1 << 2)
+MX_LINK_FEATURE_IR            = (1 << 3)
+MX_LINK_FEATURE_RC            = (1 << 4)
+
+class RCAction(Enum):
+	ACTION_POWER_TOGGLE 	= 0
+	ACTION_POWER_ON			= 1
+	ACTION_POWER_OFF		= 2
+	ACTION_VOLUME_DOWN		= 3
+	ACTION_VOLUME_UP		= 4
+	ACTION_VOLUME_MUTE		= 5
+
+class RCKey(Enum):
+    KEY_0                = 0
+    KEY_1                = 1
+    KEY_2                = 2
+    KEY_3                = 3
+    KEY_4                = 4
+    KEY_5                = 5
+    KEY_6                = 6
+    KEY_7                = 7
+    KEY_8                = 8
+    KEY_9                = 9
+    KEY_SELECT           = 10
+    KEY_BACK             = 11
+    KEY_UP               = 12
+    KEY_DOWN             = 13
+    KEY_LEFT             = 14
+    KEY_RIGHT            = 15
+    KEY_MENU             = 16
+    KEY_CONTENT_MENU     = 17
+    KEY_CHANNEL_UP       = 18
+    KEY_CHANNEL_DOWN     = 19
+    KEY_PLAY             = 20
+    KEY_PAUSE            = 21
+    KEY_STOP             = 22
+    KEY_RECORD           = 23
+    KEY_FAST_FORWARD     = 24
+    KEY_REWIND           = 25
+    KEY_RED              = 26
+    KEY_GREEN            = 27
+    KEY_YELLOW           = 28
+    KEY_BLUE             = 29
+    KEY_HELP             = 30
+    KEY_INFORMATION      = 31
+    KEY_TEXT             = 32
+    KEY_GUIDE            = 33
+    KEY_VIDEO_ON_DEMAND  = 34
+    KEY_PREVIOUS_CHANNEL = 80
+    KEY_3D_MODE          = 81
+    KEY_SUBTITLE         = 82
+    KEY_SOUND_SELECT     = 83
+    KEY_INPUT_SELECT     = 84
+    KEY_EJECT            = 85
+    KEY_NEXT_CHAPTER     = 86
+    KEY_PREVIOUS_CHAPTER = 87
+    KEY_CUSTOM_CEC       = 1280
+    KEY_INTERACTIVE      = 128
+    KEY_SEARCH           = 129
+    KEY_SKY              = 130
+    KEY_CUSTOM_SKY       = 2048
+
+class BayStatusMask:
+	FAULT = (1 << 0)
+	HIDDEN = (1 << 1)
+	POWERED = (1 << 2)
+	SIGNAL_DETECTED = (1 << 3)
+	HPD_DETECTED = (1 << 4)
+	SIGNAL_SCRAMBLED =(1 << 5)
+	HDBT_CONNECTED = (1 << 6)
+	CEC_DETECTED = (1 << 7)
+	POWERED_ON = (1 << 8)
+	POWERED_OFF = (1 << 9)
+	AUDIO_ARC_HDMI = (1 << 10)
+	AUDIO_ARC_OPTICAL = (1 << 11)
+	AUDIO_ARC_ANALOG = (1 << 12)
+	OFFLINE = (1 << 13)
+	DECODER_DISABLED = (1 << 14)
+	ENCODER_DISABLED = (1 << 15)
+
+	def __init__(self, mask:int):
+		self._mask = mask
+
+	@property
+	def fault(self) -> bool:
+		# bay is faulty
+		return (self._mask & self.FAULT) != 0
+
+	@property
+	def hidden(self) -> bool:
+		# bay is hidden
+		return (self._mask & self.HIDDEN) != 0
+
+	@property
+	def powered(self) -> bool:
+		# PoE powered on
+		return (self._mask & self.POWERED) != 0
+
+	@property
+	def signal_detected(self) -> bool:
+		# signal detected
+		return (self._mask & self.SIGNAL_DETECTED) != 0
+
+	@property
+	def hpd_detected(self) -> bool:
+		# hotplug detected
+		return (self._mask & self.HPD_DETECTED) != 0
+
+	@property
+	def hdbt_connected(self) -> bool:
+		# HDBaseT connected
+		return (self._mask & self.HDBT_CONNECTED) != 0
+
+	@property
+	def cec_detected(self) -> bool:
+		# CEC capable device connected to this bay
+		return (self._mask & self.CEC_DETECTED) != 0
+
+	@property
+	def powered_on(self) -> bool:
+		# device is powered on
+		return (self._mask & self.POWERED_ON) != 0
+
+	@property
+	def powered_off(self) -> bool:
+		# device is powered off
+		return (self._mask & self.POWERED_OFF) != 0
+
+	@property
+	def audio_arc_hdmi(self) -> bool:
+		# HDMI ARC active
+		return (self._mask & self.AUDIO_ARC_HDMI) != 0
+
+	@property
+	def audio_arc_optical(self) -> bool:
+		# optical ARC active
+		return (self._mask & self.AUDIO_ARC_OPTICAL) != 0
+
+	@property
+	def audio_arc_analog(self) -> bool:
+		# analog ARC active
+		return (self._mask & self.AUDIO_ARC_ANALOG) != 0
+
+	@property
+	def offline(self) -> bool:
+		# v2ip unit offline
+		return (self._mask & self.OFFLINE) != 0
+
+	@property
+	def decoder_disabled(self) -> bool:
+		# v2ip decoder disabled
+		return (self._mask & self.DECODER_DISABLED) != 0
+
+	@property
+	def encoder_disabled(self) -> bool:
+		# v2ip decoder disabled
+		return (self._mask & self.ENCODER_DISABLED) != 0
+
+	def __str__(self) -> str:
+		rv = ""
+		if self.fault:
+			rv += " [fault]"
+		if self.hidden:
+			rv += " [hidden]"
+		if self.powered:
+			rv += " [powered]"
+		if self.signal_detected:
+			rv += " [signal]"
+		if self.hpd_detected:
+			rv += " [hpd]"
+		if self.hdbt_connected:
+			rv += " [hdbt]"
+		if self.cec_detected:
+			rv += " [cec]"
+		if self.powered_on:
+			rv += " [powered on]"
+		if self.powered_off:
+			rv += " [powered off]"
+		if self.audio_arc_hdmi:
+			rv += " [hdmi arc]"
+		if self.audio_arc_optical:
+			rv += " [optical arc]"
+		if self.audio_arc_analog:
+			rv += " [analog arc]"
+		if self.offline:
+			rv += " [offline]"
+		if self.decoder_disabled:
+			rv += " [decoder disabled]"
+		if self.encoder_disabled:
+			rv += " [encoder disabled]"
+		if len(rv) != 0:
+			return rv[1:]
+		return "[none]"
+
+	def __eq__(self, mask:Any) -> bool:
+		if isinstance(mask, int):
+			return self._mask == mask
+		if isinstance(mask, BayStatusMask):
+			return self._mask == mask._mask
+		return False
+
+	def __ne__(self, mask:Any) -> bool:
+		return not (self == mask)
+
+
+class RCType(Enum):
+	IR = 0
+	CEC = 1
+	SKY_UK = 2
+	TIVO = 3
+	KODI = 4
+	DISH = 5
+	DIRECTV = 6
+	MX_REMOTE = 7
+
+	def __str__(self) -> str:
+		if self.value == RCType.IR.value:
+			return "IR"
+		if self.value == RCType.CEC.value:
+			return "CEC"
+		if self.value == RCType.SKY_UK.value:
+			return "Sky"
+		if self.value == RCType.TIVO.value:
+			return "TiVo"
+		if self.value == RCType.KODI.value:
+			return "Kodi"
+		if self.value == RCType.DISH.value:
+			return "Dish"
+		if self.value == RCType.DIRECTV.value:
+			return "DirecTV"
+		if self.value == RCType.MX_REMOTE.value:
+			return "MX-Remote"
+		return "Unknown"
+
+	def values() -> dict[int, str]:
+		rv:dict[int, str] = {}
+		for val in range(8):
+			rv[val] = str(RCType(val))
+		return rv
+
+class EdidProfile(Enum):
+	def __str__(self) -> str:
+		if self.value == EdidProfile.TEMPLATE_1080P_STEREO.value:
+			return '1080p stereo'
+		if self.value == EdidProfile.FIXED.value:
+			return 'fixed'
+		if self.value == EdidProfile.TEMPLATE_4K.value:
+			return '4K'
+		if self.value == EdidProfile.TEMPLATE_1080P_5_1.value:
+			return '1080p 5.1'
+		if self.value == EdidProfile.TEMPLATE_720P.value:
+			return '720p'
+		if self.value == EdidProfile.TEMPLATE_1080P_7_1.value:
+			return '1080p 7.1'
+		if self.value == EdidProfile.TEMPLATE_4K_HDR_STEREO.value:
+			return '4K HDR Stereo'
+		if self.value == EdidProfile.TEMPLATE_4K_HDR_7_1.value:
+			return '4K HDR 7.1'
+		if self.value == EdidProfile.TEMPLATE_4K_HDR_AVR_ONLY.value:
+			return '4K HDR AVR'
+		if self.value == EdidProfile.LOWEST_COMMON_DENOMINATOR.value:
+			return 'lowest common denominator'
+		if self.value == EdidProfile.LOWEST_COMMON_DENOMINATOR_ALL.value:
+			return 'lowest common denominator (all sinks)'
+		if self.value == EdidProfile.TEMPLATE_4K_HDR_ATMOS.value:
+			return '4K HDR Dolby Atmos'
+		if (self.value >= EdidProfile.SINK_1.value) and (self.value <= EdidProfile.SINK_32.value):
+			return f'copy from sink #{self.value - EdidProfile.SINK_1.value + 1}'
+		return "unknown"
+
+	TEMPLATE_1080P_STEREO = 0
+	FIXED = 1
+	TEMPLATE_4K = 2
+	TEMPLATE_1080P_5_1 = 3
+	TEMPLATE_720P = 4
+	TEMPLATE_1080P_7_1 = 5
+	TEMPLATE_4K_7_1 = 6
+	TEMPLATE_4K_HDR_STEREO = 7
+	TEMPLATE_4K_HDR_7_1 = 8
+	TEMPLATE_4K_HDR_AVR_ONLY = 9
+	LOWEST_COMMON_DENOMINATOR = 10
+	LOWEST_COMMON_DENOMINATOR_ALL = 11
+	TEMPLATE_4K_HDR_ATMOS = 12
+	SINK_1 = 101
+	SINK_2 = 102
+	SINK_3 = 103
+	SINK_4 = 104
+	SINK_5 = 105
+	SINK_6 = 106
+	SINK_7 = 107
+	SINK_8 = 108
+	SINK_9 = 109
+	SINK_10 = 110
+	SINK_11 = 111
+	SINK_12 = 112
+	SINK_13 = 113
+	SINK_14 = 114
+	SINK_15= 115
+	SINK_16 = 116
+	SINK_17 = 117
+	SINK_18 = 118
+	SINK_19 = 119
+	SINK_20 = 120
+	SINK_21 = 121
+	SINK_22 = 122
+	SINK_23 = 123
+	SINK_24 = 124
+	SINK_25 = 125
+	SINK_26 = 126
+	SINK_27 = 127
+	SINK_28 = 128
+	SINK_29 = 129
+	SINK_30 = 130
+	SINK_31 = 131
+	SINK_32 = 132
+	UNKNOWN = 0xFFF
+
+	def values(nb_sinks:int|None=None) -> dict[int, str]:
+		rv:dict[int, str] = {}
+		for val in range(13):
+			rv[val] = str(EdidProfile(val))
+		if nb_sinks is None:
+			nb_sinks = 32
+		for val in range(101, 101 + nb_sinks):
+			rv[val] = str(EdidProfile(val))
+		return rv

mx_remote/proto/Data.py

@@ -0,0 +1,142 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+class MuteStatus:
+    ''' mute left/right status '''
+    def __init__(self, val:int):
+        self._val = val
+
+    @property
+    def value(self) -> int:
+        return self._val
+
+    @property
+    def left(self) -> bool:
+        # left channel muted
+        return ((self._val & (1 << 0)) != 0)
+
+    @property
+    def right(self) -> bool:
+        # right channel muted
+        return ((self._val & (1 << 1)) != 0)
+
+    @property
+    def muted(self) -> bool:
+        # left or right channel muted (or both)
+        return (self._val != 0)
+
+    def __str__(self) -> str:
+        return f"left:{self.left} right:{self.right}"
+
+class VolumeMuteStatus:
+    ''' volume and mute status '''
+    def __init__(self, volume_left:int, volume_right:int, muted_left:bool=None, muted_right:bool=None):
+        self._volume_left = volume_left
+        self._volume_right = volume_right
+        self._muted_left = muted_left
+        self._muted_right = muted_right
+
+    @property
+    def value(self) -> bytes:
+        return bytes(bytearray([
+            self.volume_left,
+            self.volume_right,
+            self.muted_value,
+        ]))
+
+    @property
+    def muted_value(self) -> int:
+        if not self.muted:
+            return 0
+        if self.muted_left and self.muted_right:
+            return 3
+        if self.muted_left:
+            return 1
+        return 2
+
+    @property
+    def volume(self) -> int:
+        # combined left/right volume %
+        vr = self._volume_right
+        if vr is None:
+            return self._volume_left if self._volume_left is not None else 0
+        return int((vr + self._volume_left) / 2.0)
+
+    @volume.setter
+    def volume(self, volume:int) -> None:
+        self.volume_left = volume
+        if self._volume_right is not None:
+            self.volume_right = volume
+
+    @property
+    def volume_left(self) -> int:
+        # left channel volume
+        return self._volume_left if (self._volume_left is not None) else self.volume
+
+    @volume_left.setter
+    def volume_left(self, volume:int) -> None:
+        self._volume_left = volume
+
+    @property
+    def volume_right(self) -> int:
+        # right channel volume
+        return self._volume_right if (self._volume_right is not None) else self.volume
+
+    @volume_right.setter
+    def volume_right(self, volume:int) -> None:
+        self._volume_right = volume
+
+    @property
+    def muted(self) -> bool:
+        # combined mute left/right status
+        if (self._muted_left is None) and (self._muted_right is None):
+            return None
+        return ((self._muted_left is not None) and self._muted_left) or \
+            ((self._muted_right is not None) and self._muted_right)
+
+    @muted.setter
+    def muted(self, muted:bool) -> None:
+        self.muted_left = muted
+        if self._muted_right is not None:
+            self.muted_right = muted
+
+    @property
+    def muted_left(self) -> bool:
+        # left channel muted
+        return self._muted_left if (self._muted_left is not None) else self.muted
+
+    @muted_left.setter
+    def muted_left(self, muted:bool) -> None:
+        self._muted_left = muted
+
+    @property
+    def muted_right(self) -> bool:
+        # right channel muted
+        return self._muted_right if (self._muted_right is not None) else self.muted
+
+    @muted_right.setter
+    def muted_right(self, muted:bool) -> None:
+        self._muted_right = muted
+
+    def update(self, other:'VolumeMuteStatus') -> bool:
+        changed = False
+        if other._volume_left is not None:
+            changed = changed or (self._volume_left is None) or (self._volume_left != other._volume_left)
+            self._volume_left = other._volume_left
+        if other._volume_right is not None:
+            changed = changed or (self._volume_right is None) or (self._volume_right != other._volume_right)
+            self._volume_right = other._volume_right
+        if other._muted_left is not None:
+            changed = changed or (self._muted_left is None) or (self._muted_left != other._muted_left)
+            self._muted_left = other._muted_left
+        if other._muted_right is not None:
+            changed = changed or (self._muted_right is None) or (self._muted_right != other._muted_right)
+            self._muted_right = other._muted_right
+        return changed
+
+    def __str__(self) -> str:
+        return f"volume left:{self.volume_left} right:{self.volume_right} muted:{self.muted}"

mx_remote/proto/Factory.py

@@ -0,0 +1,168 @@
+##################################################
+##         MX Remote Python Interface           ##
+##                                              ##
+## author: Lars Op den Kamp (lars@opdenkamp.eu) ##
+## copyright (c) 2024 Op den Kamp IT Solutions  ##
+##################################################
+
+''' Methods for creating and processing frames '''
+from .FrameBase import FrameBase
+from .FrameHeader import FrameHeader
+from ..Interface import DeviceRegistry
+import logging
+import traceback
+
+logging.basicConfig(level=logging.DEBUG)
+
+def create_mxr_frame(uid:bytes, opcode:int, payload:bytes=None) -> bytes:
+	# create a new mx_remote frame for transmission
+	pkt = [80, 56, 1, 0 ]
+	pkt.extend(uid)
+	pkt.extend([(opcode & 0xFF), ((opcode >> 8) & 0xFF)])
+	if payload is None or len(payload) == 0:
+		pkt.extend([0, 0])
+	else:
+		l = len(payload)
+		pkt.extend([(l & 0xFF), ((l >> 8) & 0xFF)])
+		pkt.extend([payload])
+	return bytes(pkt)
+
+def process_mxr_frame(mxr:DeviceRegistry, data:bytes, addr:tuple[str,int]) -> FrameBase:
+	# decode a (received) mx_remote frame
+	from .FrameHeader import FrameHeader
+	hdr = FrameHeader(mxr, data, addr)
+	if hdr is not None:
+		try:
+			# valid frame
+			if hdr.remote_id == mxr.uid:
+				logging.debug("ignore frame sent by myself")
+				return None
+			# not one of my own, process the incoming frame
+			return _mxr_frame_factory(hdr)
+		except Exception:
+			print(f"failed to process frame: {traceback.format_exc()}")
+			raise
+	logging.warning("frame header missing")
+
+def _mxr_frame_factory(hdr:FrameHeader) -> FrameBase:
+	# create a new frame from a decoded mx_remote header
+	if hdr.opcode == 0x00:
+		from .FrameHello import FrameHello
+		return FrameHello(hdr)
+	if hdr.opcode == 0x01:
+		from .FrameDiscover import FrameDiscover
+		return FrameDiscover(hdr)
+	if hdr.opcode == 0x02:
+		from .FrameBayConfig import FrameBayConfig
+		return FrameBayConfig(hdr)
+	if hdr.opcode == 0x03:
+		from .FrameLinks import FrameLinks
+		return FrameLinks(hdr)
+	if hdr.opcode == 0x04:
+		from .FrameConnectStatus import FrameConnectStatus
+		return FrameConnectStatus(hdr)
+	if hdr.opcode == 0x05:
+		from .FramePowerChange import FramePowerChange
+		return FramePowerChange(hdr)
+	if hdr.opcode == 0x06:
+		from .FrameSignalStatus import FrameSignalStatus
+		return FrameSignalStatus(hdr)
+	if hdr.opcode == 0x07:
+		from .FrameEDID import FrameEDID
+		return FrameEDID(hdr)
+	if hdr.opcode == 0x08:
+		from .FrameRoutingChange import FrameRoutingChange
+		return FrameRoutingChange(hdr)
+	if hdr.opcode == 0x0A:
+		from .FrameRCIr import FrameRCIr
+		return FrameRCIr(hdr)
+	if hdr.opcode == 0x0B:
+		from .FrameRCKey import FrameRCKey
+		return FrameRCKey(hdr)
+	if hdr.opcode == 0x0D:
+		from .FrameRCAction import FrameRCAction
+		return FrameRCAction(hdr)
+	if hdr.opcode == 0x0F:
+		from .FrameVolumeUp import FrameVolumeUp
+		return FrameVolumeUp(hdr)
+	if hdr.opcode == 0x10:
+		from .FrameVolumeDown import FrameVolumeDown
+		return FrameVolumeDown(hdr)
+	if hdr.opcode == 0x12:
+		from .FrameVolume import FrameVolume
+		return FrameVolume(hdr)
+	if hdr.opcode == 0x14:
+		from .FrameVolumeSet import FrameVolumeSet
+		return FrameVolumeSet(hdr)
+	if hdr.opcode == 0x15:
+		from .FrameSysTemperature import FrameSysTemperature
+		return FrameSysTemperature(hdr)
+	if hdr.opcode == 0x1F:
+		from .FrameV2IPSourceSwitch import FrameV2IPSourceSwitch
+		return FrameV2IPSourceSwitch(hdr)
+	if hdr.opcode == 0x16:
+		from .FramePDUState import FramePDUState
+		return FramePDUState(hdr)
+	if hdr.opcode == 0x20:
+		from .FrameV2IPLink import FrameV2IPLinkStatus
+		return FrameV2IPLinkStatus(hdr)
+	if hdr.opcode == 0x22:
+		from .FrameSetName import FrameSetName
+		return FrameSetName(hdr)
+	if hdr.opcode == 0x23:
+		from .FrameBayConfigSecondary import FrameBayConfigSecondary
+		return FrameBayConfigSecondary(hdr)
+	if hdr.opcode == 0x26:
+		from .FrameV2IPSources import FrameV2IPSources
+		return FrameV2IPSources(hdr)
+	if hdr.opcode == 0x27:
+		from .FrameBayHide import FrameBayHide
+		return FrameBayHide(hdr)
+	if hdr.opcode == 0x28:
+		from .FrameReboot import FrameReboot
+		return FrameReboot(hdr)
+	if hdr.opcode == 0x29:
+		from .FrameNetworkStatus import FrameNetworkStatus
+		return FrameNetworkStatus(hdr)
+	if hdr.opcode == 0x2A:
+		from .FrameFirmwareVersion import FrameFirmwareVersion
+		return FrameFirmwareVersion(hdr)
+	if hdr.opcode == 0x30:
+		from .FrameTopology import FrameTopology
+		return FrameTopology(hdr)
+	if hdr.opcode == 0x31:
+		from .FrameSignalStatusNew import FrameSignalStatusNew
+		return FrameSignalStatusNew(hdr)
+	if hdr.opcode == 0x32:
+		from .FrameMirrorStatus import FrameMirrorStatus
+		return FrameMirrorStatus(hdr)
+	if hdr.opcode == 0x34:
+		from .FrameEDIDProfile import FrameEDIDProfile
+		return FrameEDIDProfile(hdr)
+	if hdr.opcode == 0x36:
+		from .FrameV2IPSetMaster import FrameV2IPSetMaster
+		return FrameV2IPSetMaster(hdr)
+	if hdr.opcode == 0x38:
+		from .FrameFilterStatus import FrameFilterStatus
+		return FrameFilterStatus(hdr)
+	if hdr.opcode == 0x39:
+		from .FrameBayStatus import FrameBayStatus
+		return FrameBayStatus(hdr)
+	if hdr.opcode == 0x3B:
+		from .FrameMeshOperation import FrameMeshOperation
+		return FrameMeshOperation(hdr)
+	if hdr.opcode == 0x3C:
+		from .FrameV2IPDeviceConfiguration import FrameV2IPDeviceConfiguration
+		return FrameV2IPDeviceConfiguration(hdr)
+	if hdr.opcode == 0x3D:
+		from .FrameAmpZoneSettings import FrameAmpZoneSettings
+		return FrameAmpZoneSettings(hdr)
+	if hdr.opcode == 0x3E:
+		from .FrameAmpDolbySettings import FrameAmpDolbySettings
+		return FrameAmpDolbySettings(hdr)
+	if hdr.opcode == 0x3F:
+		from .FrameV2IPStats import FrameV2IPStats
+		return FrameV2IPStats(hdr)
+	logging.warning(f"opcode {hdr.opcode:02X} is not processed")
+	return None
+