pysdcp-extended 0.1.0__tar.gz

pysdcp_extended-0.1.0/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+pySDCP: Copyright (c) 2017 Guy Shapira
+pySDCP-extended: Copyright (c) 2024 kennymc.c
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pysdcp_extended-0.1.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: pysdcp-extended
+Version: 0.1.0
+Summary: Extended SDCP / PJ Talk library to control Sony projectors
+Home-page: https://github.com/kennymc-c/pySDCP-extended
+License: MIT
+Keywords: sdcp,pjtalk,sony,projector,ip-control,home-automation
+Author: kennymc.c
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Home Automation
+Classifier: Topic :: Software Development :: Libraries
+Project-URL: Repository, https://github.com/kennymc-c/pySDCP-extended
+Description-Content-Type: text/markdown
+
+# pySDCP-extended
+
+<!---[![PyPi](https://img.shields.io/pypi/v/pysdcp-extended.svg)](https://pypi.org/project/pysdcp-extended)--->
+
+Extended Sony SDCP / PJ Talk projector control.
+
+Python **3** library to query and control Sony Projectors using SDCP (PJ Talk) protocol over IP.
+
+## Features
+
+* Auto discover projector using SDAP (Simple Display Advertisement Protocol)
+* Query and change power & input (HDMI 1 + 2)
+* Set aspect ratio/zoom and calibration presets
+
+### Extended Features
+
+* Support for more commands (added to protocol.py)
+* Query and set picture muting
+* Query lamp hours
+* Query model name and serial number
+* Show response error message from the projector
+* Set a custom PJ Talk community & UDP advertisement SDAP port and TCP SDCP port
+
+## Protocol Documentation
+
+* [Link](https://www.digis.ru/upload/iblock/f5a/VPL-VW320,%20VW520_ProtocolManual.pdf)
+* [Link](https://docs.sony.com/release/VW100_protocol.pdf)
+
+## Supported Projectors
+
+Supported Sony projectors should include:
+
+* VPL-HW65ES
+* VPL-VW100
+* VPL-VW260
+* VPL-VW270
+* VPL-VW285
+* VPL-VW315
+* VPL-VW320
+* VPL-VW328
+* VPL-VW365
+* VPL-VW515
+* VPL-VW520
+* VPL-VW528
+* VPL-VW665
+
+## Installation
+
+```pip install pysdcp-extended```
+
+## Examples
+
+Sending any command will initiate auto discovery of the projector if none is known and will carry on the command. So just go for it and maybe you get lucky
+
+```python
+import pysdcp_extended
+
+my_projector = pysdcp_extended.Projector()
+
+my_projector.get_power()
+my_projector.set_power(True)
+```
+
+Skip discovery to save time or if you know the IP of the projector
+
+```python
+my_known_projector = pysdcp.Projector('10.1.2.3')
+my_known_projector.set_HDMI_input(2)
+```
+
+You can also set a custom PJ Talk community and tcp/udp port. By default "SONY" will be used as the community and 53862 as udp port for SDAP advertisement and 53484 as tcp port for SDCP
+
+```python
+my_known_projector = pysdcp.Projector(ip='10.1.2.3', community="THEATER", udp_port=53860, tcp_port=53480)
+```
+
+### Commands from protocol.py
+
+While you can use the build in functions like get_power() or set_HDMI_input() you can also directly send any command from protocol.py like this
+If you need to use more commands, just add to _protocol.py_, and send it like this:
+
+```python
+from pysdcp_extended.protocol.py import *
+
+my_projector._send_command(action=ACTIONS["SET"], command=COMMANDS_IR["CURSOR_UP"])
+```
+
+Please note that commands in `COMMANDS_IR` work as fire and forget and you only get a response if there is a timeout.
+
+## Credits
+
+This plugin is an extended fork of [pySDCP](https://github.com/Galala7/pySDCP) by [Galala7](https://github.com/Galala7) which is based on [sony-sdcp-com](https://github.com/vokkim/sony-sdcp-com) NodeJS library by [vokkim](https://github.com/vokkim).
+
+## See also
+
+* [homebridge-sony-sdcp](https://github.com/Galala7/homebridge-sony-sdcp) - Homebridge plugin to control Sony Projectors (based on Galala7/pySDCP)
+* [ucr2-integration-sonySDCP](https://github.com/kennymc-c/ucr2-integration-sonySDCP) - SDCP integration for Unfolded Circle Remote devices
+

pysdcp_extended-0.1.0/README.md

@@ -0,0 +1,97 @@
+# pySDCP-extended
+
+<!---[![PyPi](https://img.shields.io/pypi/v/pysdcp-extended.svg)](https://pypi.org/project/pysdcp-extended)--->
+
+Extended Sony SDCP / PJ Talk projector control.
+
+Python **3** library to query and control Sony Projectors using SDCP (PJ Talk) protocol over IP.
+
+## Features
+
+* Auto discover projector using SDAP (Simple Display Advertisement Protocol)
+* Query and change power & input (HDMI 1 + 2)
+* Set aspect ratio/zoom and calibration presets
+
+### Extended Features
+
+* Support for more commands (added to protocol.py)
+* Query and set picture muting
+* Query lamp hours
+* Query model name and serial number
+* Show response error message from the projector
+* Set a custom PJ Talk community & UDP advertisement SDAP port and TCP SDCP port
+
+## Protocol Documentation
+
+* [Link](https://www.digis.ru/upload/iblock/f5a/VPL-VW320,%20VW520_ProtocolManual.pdf)
+* [Link](https://docs.sony.com/release/VW100_protocol.pdf)
+
+## Supported Projectors
+
+Supported Sony projectors should include:
+
+* VPL-HW65ES
+* VPL-VW100
+* VPL-VW260
+* VPL-VW270
+* VPL-VW285
+* VPL-VW315
+* VPL-VW320
+* VPL-VW328
+* VPL-VW365
+* VPL-VW515
+* VPL-VW520
+* VPL-VW528
+* VPL-VW665
+
+## Installation
+
+```pip install pysdcp-extended```
+
+## Examples
+
+Sending any command will initiate auto discovery of the projector if none is known and will carry on the command. So just go for it and maybe you get lucky
+
+```python
+import pysdcp_extended
+
+my_projector = pysdcp_extended.Projector()
+
+my_projector.get_power()
+my_projector.set_power(True)
+```
+
+Skip discovery to save time or if you know the IP of the projector
+
+```python
+my_known_projector = pysdcp.Projector('10.1.2.3')
+my_known_projector.set_HDMI_input(2)
+```
+
+You can also set a custom PJ Talk community and tcp/udp port. By default "SONY" will be used as the community and 53862 as udp port for SDAP advertisement and 53484 as tcp port for SDCP
+
+```python
+my_known_projector = pysdcp.Projector(ip='10.1.2.3', community="THEATER", udp_port=53860, tcp_port=53480)
+```
+
+### Commands from protocol.py
+
+While you can use the build in functions like get_power() or set_HDMI_input() you can also directly send any command from protocol.py like this
+If you need to use more commands, just add to _protocol.py_, and send it like this:
+
+```python
+from pysdcp_extended.protocol.py import *
+
+my_projector._send_command(action=ACTIONS["SET"], command=COMMANDS_IR["CURSOR_UP"])
+```
+
+Please note that commands in `COMMANDS_IR` work as fire and forget and you only get a response if there is a timeout.
+
+## Credits
+
+This plugin is an extended fork of [pySDCP](https://github.com/Galala7/pySDCP) by [Galala7](https://github.com/Galala7) which is based on [sony-sdcp-com](https://github.com/vokkim/sony-sdcp-com) NodeJS library by [vokkim](https://github.com/vokkim).
+
+## See also
+
+* [homebridge-sony-sdcp](https://github.com/Galala7/homebridge-sony-sdcp) - Homebridge plugin to control Sony Projectors (based on Galala7/pySDCP)
+* [ucr2-integration-sonySDCP](https://github.com/kennymc-c/ucr2-integration-sonySDCP) - SDCP integration for Unfolded Circle Remote devices

pysdcp_extended-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "pysdcp-extended"
+version = "0.1.0"
+description = "Extended SDCP / PJ Talk library to control Sony projectors"
+authors = ["kennymc.c"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/kennymc-c/pySDCP-extended"
+keywords = ["sdcp", "pjtalk", "sony", "projector", "ip-control", "home-automation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Home Automation",
+    "Programming Language :: Python :: 3.11",
+]
+# Need as the package name contains a hyphen
+packages = [
+    { include = "pysdcp_extended" },
+]
+
+[tool.poetry.dependencies]
+python = "^3.11"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

pysdcp_extended-0.1.0/pysdcp_extended/__init__.py

@@ -0,0 +1,285 @@
+#! py3
+
+import socket
+from collections import namedtuple
+from struct import *
+
+from pysdcp_extended.protocol import *
+
+Header = namedtuple("Header", ['version', 'category', 'community'])
+ProjInfo = namedtuple("ProjInfo", ['id', 'product_name', 'serial_number', 'power_state', 'location'])
+
+
+def create_command_buffer(header: Header, action, command, data=None):
+    # create bytearray in the right size
+    if data is not None:
+        my_buf = bytearray(12)
+    else:
+        my_buf = bytearray(10)
+    # header
+    my_buf[0] = 2  # only works with version 2, don't know why
+    my_buf[1] = header.category
+    # community
+    my_buf[2] = ord(header.community[0])
+    my_buf[3] = ord(header.community[1])
+    my_buf[4] = ord(header.community[2])
+    my_buf[5] = ord(header.community[3])
+    # command
+    my_buf[6] = action
+    pack_into(">H", my_buf, 7, command)
+    if data is not None:
+        # add data len
+        my_buf[9] = 2  # Data is always 2 bytes
+        # add data
+        pack_into(">H", my_buf, 10, data)
+    else:
+        my_buf[9] = 0
+    return my_buf
+
+
+def process_command_response(msgBuf):
+    my_header = Header(
+        version=int(msgBuf[0]),
+        category=int(msgBuf[1]),
+        community=decode_text_field(msgBuf[2:6]))
+    is_success = bool(msgBuf[6])
+    command = unpack(">H", msgBuf[7:9])[0]
+    data_len = int(msgBuf[9])
+    if data_len != 0:
+        data = unpack(">H", msgBuf[10:10 + data_len])[0]
+    else:
+        data = None
+    return my_header, is_success, command, data
+
+
+def process_SDAP(SDAP_buffer) -> (Header, ProjInfo):
+    try:
+        my_header = Header(
+            version=int(SDAP_buffer[2]),
+            category=int(SDAP_buffer[3]),
+            community=decode_text_field(SDAP_buffer[4:8]))
+        my_info = ProjInfo(
+            id=SDAP_buffer[0:2].decode(),
+            product_name=decode_text_field(SDAP_buffer[8:20]),
+            serial_number=unpack('>I', SDAP_buffer[20:24])[0],
+            power_state=unpack('>H', SDAP_buffer[24:26])[0],
+            location=decode_text_field(SDAP_buffer[26:]))
+    except Exception as e:
+        print("Error parsing SDAP packet: {}".format(e))
+        raise
+    return my_header, my_info
+
+
+def decode_text_field(buf):
+    """
+    Convert char[] string in buffer to python str object
+    :param buf: bytearray with array of chars
+    :return: string
+    """
+    return buf.decode().strip(b'\x00'.decode())
+
+
+class Projector:
+    def __init__(self, ip: str = None, community: str = "SONY", udp_port: int = 53862, tcp_port: int = 53484):
+        """
+        Base class for projector communication. 
+        Enables communication with Projector, Sending commands and Querying Power State
+         
+        :param ip: str, IP address for projector. If given, will create a projector with default values to communicate
+            with projector on the given ip.  i.e. "10.0.0.5"
+        :param community: str, PJ Talk Community for the projector. If not given "SONY" will be used
+        :param udp_port: int, SDAP Advertisement UDP port. If not given 53862 will be used
+        :param tcp_port: int, PJ Talk/SDCP TCP port. If not given 53484 will be used
+        """
+        self.info = ProjInfo(
+            product_name=None,
+            serial_number=None,
+            power_state=None,
+            location=None,
+            id=None)
+        if ip is None:
+            # Create empty Projector object
+            self.ip = None
+            self.header = Header(version=None, category=None, community=None)
+            self.is_init = False
+        else:
+            # Create projector from known ip
+            # Set default values to enable immediately communication with known project (ip)
+            self.ip = ip
+            self.header = Header(category=10, version=2, community=community)
+            self.is_init = True
+
+        # Default ports
+        self.UDP_IP = ""
+        self.UDP_PORT = udp_port
+        self.TCP_PORT = tcp_port
+        self.TCP_TIMEOUT = 2
+        self.UDP_TIMEOUT = 31
+
+        # Valid settings
+        self.SCREEN_SETTINGS = {
+            "ASPECT_RATIO": ASPECT_RATIOS,
+            "PICTURE_POSITION": PICTURE_POSITIONS,
+            }
+
+    def __eq__(self, other):
+        return self.info.serial_number == other.info.serial_number
+
+    def _send_command(self, action, command, data=None, timeout=None):
+        timeout = timeout if timeout is not None else self.TCP_TIMEOUT
+        if not self.is_init:
+            self.find_projector()
+        if not self.is_init:
+            raise Exception("No projector found and / or specified")
+
+        my_buf = create_command_buffer(self.header, action, command, data)
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(timeout)
+        try:
+            sock.connect((self.ip, self.TCP_PORT))
+            sent = sock.send(my_buf)
+        except socket.timeout as e:
+            raise Exception("Timeout while trying to send command {}".format(command)) from e
+
+        if len(my_buf) != sent:
+            raise ConnectionError(
+              "Failed sending entire buffer to projector. Sent {} out of {} !".format(sent, len(my_buf)))
+
+        #Check if command is an simulated ir command without a response from the projector and always return true to avoid a timeout
+        if data is None and str(hex(command)).startswith(("0x17", "0x19", "0x1B")):
+            sock.close()
+
+            return True
+        else:
+            response_buf = sock.recv(1024)
+
+            sock.close()
+
+            _, is_success, _, data = process_command_response(response_buf)
+
+            if not is_success:
+                command = "{:x}".format(command)
+                try:
+                    error_msg = RESPONSE_ERRORS[data]
+                except KeyError:
+                    error_code = "{:x}".format(data)
+                    error_msg = "Unknown error code: " + error_code
+                raise Exception("Received failed status from projector while sending command 0x" + command + ". " + error_msg)
+
+            return data
+
+    def find_projector(self, udp_ip: str = None, udp_port: int = None, timeout=None):
+
+        self.UDP_PORT = udp_port if udp_port is not None else self.UDP_PORT
+        self.UDP_IP = udp_ip if udp_ip is not None else self.UDP_IP
+        timeout = timeout if timeout is not None else self.UDP_TIMEOUT
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+        sock.bind((self.UDP_IP, self.UDP_PORT))
+
+        sock.settimeout(timeout)
+        try:
+            SDAP_buffer, addr = sock.recvfrom(1028)
+        except socket.timeout:
+            return False
+
+        self.header, self.info = process_SDAP(SDAP_buffer)
+        self.ip = addr[0]
+        self.is_init = True
+
+    def get_pjinfo(self, udp_ip: str = None, udp_port: int = None, timeout=None):
+        '''
+        Returns ip, serial and model name from projector via SDAP advertisement service as a dictionary. Can take up to 30 seconds.
+        '''
+        self.UDP_PORT = udp_port if udp_port is not None else self.UDP_PORT
+        self.UDP_IP = udp_ip if udp_ip is not None else self.UDP_IP
+        timeout = timeout if timeout is not None else self.UDP_TIMEOUT
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+        sock.bind((self.UDP_IP, self.UDP_PORT))
+
+        sock.settimeout(timeout)
+        try:
+            SDAP_buffer, addr = sock.recvfrom(1028)
+        except socket.timeout as e:
+            raise Exception("Timeout while waiting for data from projector") from e
+
+        serial = unpack('>I', SDAP_buffer[20:24])[0]
+        model = decode_text_field(SDAP_buffer[8:20])
+        ip = addr[0]
+
+        result = {"model":model, "serial":serial, "ip":ip}
+
+        return result
+
+    def set_power(self, on=True):
+        self._send_command(action=ACTIONS["SET"], command=COMMANDS["SET_POWER"],
+                           data=POWER_STATUS["START_UP"] if on else POWER_STATUS["STANDBY"])
+        return True
+
+    def set_HDMI_input(self, hdmi_num: int):
+        self._send_command(action=ACTIONS["SET"], command=COMMANDS["INPUT"],
+                           data=INPUTS["HDMI1"] if hdmi_num == 1 else INPUTS["HDMI2"])
+        return True
+
+    def get_input(self):
+        data = self._send_command(action=ACTIONS["GET"], command=COMMANDS["INPUT"])
+        if data == INPUTS["HDMI1"]:
+            return "HDMI 1"
+        elif data == INPUTS["HDMI2"]:
+            return "HDMI 2"
+
+    def set_screen(self, command: str, value: str):
+        valid_values = self.SCREEN_SETTINGS.get(command)
+        if valid_values is None:
+            raise Exception("Invalid screen setting {}".format(command))
+
+        if value not in valid_values:
+            raise Exception("Invalid parameter: {}. Expected one of: {}".format(value, valid_values.keys()))
+
+        self._send_command(action=ACTIONS["SET"], command=COMMANDS[command],
+                           data=valid_values[value])
+        return True
+
+    def get_power(self):
+        data = self._send_command(action=ACTIONS["GET"], command=COMMANDS["GET_STATUS_POWER"])
+        if data == POWER_STATUS["STANDBY"] or data == POWER_STATUS["COOLING"] or data == POWER_STATUS["COOLING2"]:
+            return False
+        else:
+            return True
+
+    def get_muting(self):
+        data = self._send_command(action=ACTIONS["GET"], command=COMMANDS["PICTURE_MUTING"])
+        if data == PICTURE_MUTING["OFF"]:
+            return False
+        else:
+            return True
+
+    def set_muting(self, on=True):
+        self._send_command(action=ACTIONS["SET"], command=COMMANDS["PICTURE_MUTING"],
+                           data=PICTURE_MUTING["ON"] if on else PICTURE_MUTING["OFF"])
+        return True
+
+    def get_lamp_hours(self):
+        data = self._send_command(action=ACTIONS["GET"], command=COMMANDS["GET_STATUS_LAMP_TIMER"])
+        hours = "{:d}".format(data)
+        return hours
+
+
+if __name__ == '__main__':
+    # b = Projector()
+    # b.find_projector(timeout=1)
+    # # print(b.get_power())
+    # # b = Projector("10.0.0.139")
+    # # #
+    # print(b.get_power())
+    # print(b.set_power(False))
+    # # import time
+    # # time.sleep(7)
+    # print (b.set_HDMI_input(1))
+    # # time.sleep(7)
+    # # print (b.set_HDMI_input(2))
+    pass

pysdcp_extended-0.1.0/pysdcp_extended/protocol.py

@@ -0,0 +1,184 @@
+# Defines and protocol details from here: https://www.digis.ru/upload/iblock/f5a/VPL-VW320,%20VW520_ProtocolManual.pdf
+
+ACTIONS = {
+    "GET": 0x01,
+    "SET": 0x00
+}
+
+#Command
+
+#Fire and forget, no response from the projector
+COMMANDS_IR = {
+    #PROJECTOR=17, PROJECTOR-E=19, PROJECTOR-EE=1B
+    "MENU": 0x1729,
+    "CURSOR_RIGHT": 0x1733,
+    "CURSOR_LEFT": 0x1734,
+    "CURSOR_UP": 0x1735,
+    "CURSOR_DOWN": 0x1736,
+    "CURSOR_ENTER": 0x175A,
+    "LENS_SHIFT_UP": 0x1772,
+    "LENS_SHIFT_DOWN": 0x1773,
+    "LENS_SHIFT_LEFT": 0x1902,
+    "LENS_SHIFT_RIGHT": 0x1903,
+    "LENS_FOCUS_FAR": 0x1774,
+    "LENS_FOCUS_NEAR": 0x1775,
+    "LENS_ZOOM_LARGE": 0x1777,
+    "LENS_ZOOM_SMALL": 0x1778,
+}
+
+COMMANDS = {
+    "SET_POWER": 0x0130,
+    "CALIBRATION_PRESET": 0x0002,
+    "LAMP_CONTROL": 0x001A,
+    "MOTIONFLOW": 0x0059,
+    "HDR": 0x007C,
+    "INPUT_LAG_REDUCTION": 0x0099,
+    "PICTURE_POSITION": 0x0066,
+    "ASPECT_RATIO": 0x0020,
+    "HDMI1_DYNAMIC_RANGE": 0x006E,
+    "HDMI2_DYNAMIC_RANGE": 0x006F,
+    "2D_3D_DISPLAY_SELECT": 0x0060,
+    "3D_FORMAT": 0x0061,
+    "INPUT": 0x0001,
+    "PICTURE_MUTING": 0x0030,
+    "MENU_POSITION": 0x00A6,
+    "GET_STATUS_ERROR": 0x0101,
+    "GET_STATUS_POWER": 0x0102,
+    "GET_STATUS_LAMP_TIMER": 0x0113,
+}
+
+#Data
+
+CALIBRATION_PRESETS = {
+    "CINEMA_FILM_1": 0x0000,
+    "CINEMA_FILM_2": 0x0001,
+    "REF": 0x0002,
+    "TV": 0x0003,
+    "PHOTO": 0x0004,
+    "GAME": 0x0005,
+    "BRIGHT_CINEMA": 0x0006,
+    "BRIGHT_TV": 0x0007,
+    "USER": 0x0008,
+}
+
+LAMP_CONTROL= {
+    "LOW": 0x0000,
+    "HIGH": 0x0001,
+}
+
+MOTIONFLOW = {
+    "OFF": 0x0000,
+    "SMOTH_HIGH": 0x0001,
+    "SMOTH_LOW": 0x0002,
+    "IMPULSE": 0x0003,
+    "COMBINATION": 0x0004,
+    "TRUE_CINEMA": 0x0005
+}
+
+HDR = {
+    "OFF": 0x0000,
+    "ON": 0x0001,
+    "AUTO": 0x0002,
+}
+
+INPUT_LAG_REDUCTION= {
+    "OFF": 0x0000,
+    "ON": 0x0001,
+}
+
+PICTURE_POSITIONS = {
+    "1_85": 0x0000,
+    "2_35": 0x0001,
+    "CUSTOM_1": 0x0002,
+    "CUSTOM_2": 0x0003,
+    "CUSTOM_3": 0x0004
+}
+
+ASPECT_RATIOS = {
+    "NORMAL": 0x0001,
+    "V_STRETCH": 0x000B,
+    "ZOOM_1_85": 0x000C,
+    "ZOOM_2_35": 0x000D,
+    "STRETCH": 0x000E,
+    "SQUEEZE": 0x000F
+}
+
+DYNAMIC_RANGES = {
+    "AUTO": 0x0000,
+    "LIMITED": 0x0001,
+    "FULL": 0x0002
+}
+
+TWO_D_THREE_D_SELECT = {
+    "AUTO": 0x0000,
+    "3D": 0x0001,
+    "2D": 0x0002,
+}
+
+THREE_D_FORMATS = {
+    "SIMULATED_3D": 0x0000,
+    "SIDE_BY_SIDE": 0x0001,
+    "OVER_UNDER": 0x0002,
+}
+
+INPUTS = {
+    "HDMI1": 0x002,
+    "HDMI2": 0x003,
+}
+
+PICTURE_MUTING = {
+    "OFF": 0x0000,
+    "ON": 0x0001,
+}
+
+MENU_POSITIONS= {
+    "BOTTOM_LEFT": 0x0000,
+    "CENTER": 0x0001,
+}
+
+#Response data
+
+ERROR_STATUS = {
+    "NO_ERROR": 0,
+    "LAMP_ERROR": 1,
+    "FAN_ERROR": 2,
+    "COVER_ERROR": 4,
+    "TEMP_ERROR": 8,
+    "D5V_ERROR": 10,
+    "POWER_ERROR": 20,
+    "TEMP_WARNING": 40,
+}
+
+POWER_STATUS = {
+    "STANDBY": 0,
+    "START_UP": 1,
+    "START_UP_LAMP": 2,
+    "POWER_ON": 3,
+    "COOLING": 4,
+    "COOLING2": 5
+}
+
+RESPONSE_ERRORS = {
+    0x101: "Item Error: Invalid Item",
+    0x102: "Item Error: Invalid Item Request",
+    0x103: "Item Error: Invalid Length",
+    0x104: "Item Error: Invalid Data",
+    0x111: "Item Error: Short Data",
+    0x180: "Item Error: Not Applicable Item",
+    0x201: "Community Error: Different Community",
+    0x1001: "Request Error: Invalid Version",
+    0x1002: "Request Error: Invalid Category",
+    0x1003: "Request Error: Invalid Request",
+    0x1011: "Request Error: Short Header",
+    0x1012: "Request Error: Short Community",
+    0x1013: "Request Error: Short Command",
+    0xF001: "Comm Error: Timeout",
+    0xF010: "Comm Error: Check Sum Error",
+    0xF020: "Comm Error: Framing Error",
+    0xF030: "Comm Error: Parity Error",
+    0xF040: "Comm Error: Over Run Error",
+    0xF050: "Comm Error: Other Comm Error",
+    0xF0F0: "Comm Error: Unknown Response",
+    0xF110: "NVRAM Error: Read Error",
+    0xF120: "NVRAM Error: Write Error",
+}