# -*- coding: utf-8 -*- ########################################################################## # OpenLP - Open Source Lyrics Projection # # ---------------------------------------------------------------------- # # Copyright (c) 2008-2022 OpenLP Developers # # ---------------------------------------------------------------------- # # This program is free software: you can redistribute it and/or modify # # it under the terms of the GNU General Public License as published by # # the Free Software Foundation, either version 3 of the License, or # # (at your option) any later version. # # # # This program is distributed in the hope that it will be useful, # # but WITHOUT ANY WARRANTY; without even the implied warranty of # # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # # GNU General Public License for more details. # # # # You should have received a copy of the GNU General Public License # # along with this program. If not, see . # ########################################################################## """ The :mod:`openlp.core.lib.projector.pjlink` module provides the necessary functions for connecting to a PJLink-capable projector. PJLink Class 1 Specifications ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Website: http://pjlink.jbmia.or.jp/english/dl_class1.html - Section 5-1 PJLink Specifications - Section 5-5 Guidelines for Input Terminals PJLink Class 2 Specifications ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Website: http://pjlink.jbmia.or.jp/english/dl_class2.html - Section 5-1 PJLink Specifications - Section 5-5 Guidelines for Input Terminals .. note: Function names follow the following syntax:: def process_CCCC(...): where ``CCCC`` is the PJLink command being processed """ import logging from codecs import decode from copy import copy from PyQt5 import QtCore, QtNetwork from openlp.core.common import qmd5_hash from openlp.core.common.i18n import translate from openlp.core.common.registry import Registry from openlp.core.projectors.pjlinkcommands import process_command from openlp.core.projectors.constants import CONNECTION_ERRORS, E_AUTHENTICATION, E_CONNECTION_REFUSED, E_GENERAL, \ E_NETWORK, E_NOT_CONNECTED, E_SOCKET_TIMEOUT, PJLINK_CLASS, \ PJLINK_MAX_PACKET, PJLINK_PORT, PJLINK_PREFIX, PJLINK_SUFFIX, \ PJLINK_VALID_CMD, PROJECTOR_STATE, QSOCKET_STATE, S_AUTHENTICATE, S_CONNECT, S_CONNECTED, S_CONNECTING, \ S_DATA_OK, S_NOT_CONNECTED, S_OFF, S_OK, S_ON, STATUS_CODE, STATUS_MSG log = logging.getLogger(__name__) log.debug('pjlink loaded') __all__ = ['PJLink', 'PJLinkUDP'] # Shortcuts SocketError = QtNetwork.QAbstractSocket.SocketError SocketSTate = QtNetwork.QAbstractSocket.SocketState # Add prefix here, but defer linkclass expansion until later when we have the actual # PJLink class for the command PJLINK_HEADER = '{prefix}{{linkclass}}'.format(prefix=PJLINK_PREFIX) class PJLinkUDP(QtNetwork.QUdpSocket): """ Socket service for PJLink UDP socket. """ data_received = QtCore.pyqtSignal(QtNetwork.QHostAddress, int, str, name='udp_data') # host, port, data def __init__(self, port=PJLINK_PORT): """ Socket services for PJLink UDP packets. Since all UDP packets from any projector will come into the same port, process UDP packets here then route to the appropriate projector instance as needed. :param port: UDP port to listen on """ super().__init__() self.port = port # Local defines self.search_active = False self.search_time = 30000 # 30 seconds for allowed time self.search_timer = QtCore.QTimer() self.udp_broadcast_listen_setting = False self.settings = Registry().get('settings') log.debug('(UDP:{port}) PJLinkUDP() Initialized'.format(port=self.port)) if self.settings.value('projector/udp broadcast listen'): self.udp_start() def udp_start(self): """ Start listening on UDP port """ log.debug('(UDP:{port}) Start called'.format(port=self.port)) self.readyRead.connect(self.get_datagram) self.check_settings(checked=self.settings.value('projector/udp broadcast listen')) def udp_stop(self): """ Stop listening on UDP port """ log.debug('(UDP:{port}) Stopping listener'.format(port=self.port)) self.close() self.readyRead.disconnect(self.get_datagram) @QtCore.pyqtSlot() def get_datagram(self): """ Retrieve packet and basic checks """ log.debug('(UDP:{port}) get_datagram() - Receiving data'.format(port=self.port)) read_size = self.pendingDatagramSize() if -1 == read_size: log.warning('(UDP:{port}) No data (-1)'.format(port=self.port)) return elif 0 == read_size: log.warning('(UDP:{port}) get_datagram() called when pending data size is 0'.format(port=self.port)) return elif read_size > PJLINK_MAX_PACKET: log.warning('(UDP:{port}) UDP Packet too large ({size} bytes)- ignoring'.format(size=read_size, port=self.port)) return data_in, peer_host, peer_port = self.readDatagram(read_size) data = data_in.decode('utf-8') if isinstance(data_in, bytes) else data_in log.debug('(UDP:{port}) {size} bytes received from {adx}'.format(size=len(data), adx=peer_host.toString(), port=self.port)) log.debug('(UDP:{port}) packet "{data}"'.format(data=data, port=self.port)) log.debug('(UDP:{port}) Sending data_received signal to projectors'.format(port=self.port)) self.data_received.emit(peer_host, self.localPort(), data) return def search_start(self): """ Start search for projectors on local network """ self.search_active = True # TODO: Send SRCH packet here self.search_timer.singleShot(self.search_time, self.search_stop) @QtCore.pyqtSlot() def search_stop(self): """ Stop search """ self.search_active = False self.search_timer.stop() def check_settings(self, checked): """ Update UDP listening state based on settings change. NOTE: This method is called by projector settings tab and setup/removed by ProjectorManager """ if self.udp_broadcast_listen_setting == checked: log.debug('(UDP:{port}) No change to status - skipping'.format(port=self.port)) return self.udp_broadcast_listen_setting = checked if self.udp_broadcast_listen_setting: if self.state() == self.ListeningState: log.debug('(UDP:{port}) Already listening - skipping') return self.bind(self.port) log.debug('(UDP:{port}) Listening'.format(port=self.port)) else: # Close socket self.udp_stop() class PJLink(QtNetwork.QTcpSocket): """ Socket services for PJLink TCP packets. """ # Signals sent by this module changeStatus = QtCore.pyqtSignal(str, int, str) projectorStatus = QtCore.pyqtSignal(int) # Status update projectorAuthentication = QtCore.pyqtSignal(str) # Authentication error projectorNoAuthentication = QtCore.pyqtSignal(str) # PIN set and no authentication needed projectorReceivedData = QtCore.pyqtSignal() # Notify when received data finished processing projectorUpdateIcons = QtCore.pyqtSignal() # Update the status icons on toolbar def __init__(self, projector, *args, **kwargs): """ Setup for instance. Options should be in kwargs except for port which does have a default. :param projector: Database record of projector Optional parameters :param poll_time: Time (in seconds) to poll connected projector :param socket_timeout: Time (in seconds) to abort the connection if no response """ log.debug('PJLink(projector="{projector}", args="{args}" kwargs="{kwargs}")'.format(projector=projector, args=args, kwargs=kwargs)) super().__init__() self.settings_section = 'projector' self.entry = projector self.ip = self.entry.ip self.qhost = QtNetwork.QHostAddress(self.ip) self.location = self.entry.location self.mac_adx = self.entry.mac_adx self.name = self.entry.name self.notes = self.entry.notes self.pin = self.entry.pin self.port = int(self.entry.port) self.pjlink_class = PJLINK_CLASS if self.entry.pjlink_class is None else self.entry.pjlink_class self.ackn_list = {} # Replies from online projectors (Class 2 option) self.db_update = False # Use to check if db needs to be updated prior to exiting # Poll time 20 seconds unless called with something else self.poll_time = 20000 if 'poll_time' not in kwargs else kwargs['poll_time'] * 1000 # Socket timeout (in case of brain-dead projectors) 5 seconds unless called with something else self.socket_timeout = 5000 if 'socket_timeout' not in kwargs else kwargs['socket_timeout'] * 1000 # In case we're called from somewhere that only wants information self.no_poll = 'no_poll' in kwargs self.status_connect = S_NOT_CONNECTED self.last_command = '' self.projector_status = S_NOT_CONNECTED self.error_status = S_OK # Socket information # Add enough space to input buffer for extraneous \n \r self.max_size = PJLINK_MAX_PACKET + 2 self.setReadBufferSize(self.max_size) self.reset_information() self.send_queue = [] self.priority_queue = [] self.send_busy = False # Poll timer for status updates self.poll_timer = QtCore.QTimer(self) # Timer that calls the poll_loop self.poll_timer.setInterval(self.poll_time) self.poll_timer.timeout.connect(self.poll_loop) # Socket timer for some possible brain-dead projectors or network issues self.socket_timer = QtCore.QTimer(self) self.socket_timer.setInterval(self.socket_timeout) self.socket_timer.timeout.connect(self.socket_abort) # Timer for doing status updates for commands that change state and should update faster self.status_timer_checks = {} # Keep track of events for the status timer self.status_timer = QtCore.QTimer(self) self.status_timer.setInterval(2000) # 2 second interval should be fast enough self.status_timer.timeout.connect(self.status_timer_update) # Socket status signals self.connected.connect(self.check_login) self.disconnected.connect(self.disconnect_from_host) self.error.connect(self.get_error) self.projectorReceivedData.connect(self._send_command) def reset_information(self): """ Initialize instance variables. Also used to reset projector-specific information to default. """ conn_state = STATUS_CODE[QSOCKET_STATE[self.state()]] log.debug('({ip}) reset_information() connect status is {state}'.format(ip=self.entry.name, state=conn_state)) self.fan = None # ERST self.filter_time = None # FILT self.lamp = None # LAMP self.mac_adx_received = None # ACKN self.manufacturer = None # INF1 self.model = None # INF2 self.model_filter = None # RFIL self.model_lamp = None # RLMP self.mute = None # AVMT self.other_info = None # INFO self.pjlink_class = copy(PJLINK_CLASS) self.pjlink_name = None # NAME self.power = S_OFF # POWR self.projector_errors = {} # Full ERST errors self.serial_no = None # SNUM self.serial_no_received = None self.sw_version = None # SVER self.sw_version_received = None self.shutter = None # AVMT self.source_available = None # INST self.source = None # INPT # These should be part of PJLink() class, but set here for convenience if hasattr(self, 'poll_timer'): log.debug('({ip}): Calling poll_timer.stop()'.format(ip=self.entry.name)) self.poll_timer.stop() if hasattr(self, 'socket_timer'): log.debug('({ip}): Calling socket_timer.stop()'.format(ip=self.entry.name)) self.socket_timer.stop() if hasattr(self, 'status_timer'): log.debug('({ip}): Calling status_timer.stop()'.format(ip=self.entry.name)) self.status_timer.stop() self.status_timer_checks = {} self.send_busy = False self.send_queue = [] self.priority_queue = [] def socket_abort(self): """ Aborts connection and closes socket in case of brain-dead projectors. Should normally be called by socket_timer(). """ log.debug('({ip}) socket_abort() - Killing connection'.format(ip=self.entry.name)) self.disconnect_from_host(abort=True) def poll_loop(self): """ Retrieve information from projector that changes. Normally called by timer(). """ if QSOCKET_STATE[self.state()] != S_CONNECTED: log.warning('({ip}) poll_loop(): Not connected - returning'.format(ip=self.entry.name)) # Stop timer just in case it's missed elsewhere self.poll_timer.stop() return log.debug('({ip}) poll_loop(): Updating projector status'.format(ip=self.entry.name)) # The following commands do not change, so only check them once # Call them first in case other functions rely on something here if self.power == S_ON and self.source_available is None: self.send_command('INST') if self.other_info is None: self.send_command('INFO') if self.manufacturer is None: self.send_command('INF1') if self.model is None: self.send_command('INF2') if self.pjlink_name is None: self.send_command('NAME') if self.pjlink_class == '2': # Class 2 specific checks if self.serial_no is None: self.send_command('SNUM') if self.sw_version is None: self.send_command('SVER') if self.model_filter is None: self.send_command('RFIL') if self.model_lamp is None: self.send_command('RLMP') # These commands may change during connection check_list = ['POWR', 'ERST', 'LAMP', 'AVMT', 'INPT'] if self.pjlink_class == '2': check_list.extend(['FILT', 'FREZ']) for command in check_list: self.send_command(command) # Reset the poll_timer for normal operations in case of initial connection self.poll_timer.setInterval(self.poll_time) def _get_status(self, status): """ Helper to retrieve status/error codes and convert to strings. :param status: Status/Error code :returns: tuple (-1 if code not INT, None) :returns: tuple (string: code as string, None if no description) :returns: tuple (string: code as string, string: Status/Error description) """ if not isinstance(status, int): return -1, None elif status not in STATUS_MSG: return None, None else: return STATUS_CODE[status], STATUS_MSG[status] def change_status(self, status, msg=None): """ Check connection/error status, set status for projector, then emit status change signal for gui to allow changing the icons. :param status: Status code :param msg: Optional message """ if status in STATUS_CODE: log.debug('({ip}) Changing status to {status} ' '"{msg}"'.format(ip=self.entry.name, status=STATUS_CODE[status], msg=msg if msg is not None else STATUS_MSG[status])) else: log.warning('({ip}) Unknown status change code: {code}'.format(ip=self.entry.name, code=status)) return if status in CONNECTION_ERRORS: # Connection state error affects both socket and projector self.error_status = status self.status_connect = E_NOT_CONNECTED elif status >= S_NOT_CONNECTED and status in QSOCKET_STATE: # Socket connection status update self.status_connect = status # Check if we need to update error state as well if self.error_status != S_OK and status != S_NOT_CONNECTED: self.error_status = S_OK elif status >= S_NOT_CONNECTED and status in PROJECTOR_STATE: # Only affects the projector status self.projector_status = status # These log entries are for troubleshooting only (status_code, status_message) = self._get_status(self.status_connect) log.debug('({ip}) status_connect: {code}: "{message}"'.format(ip=self.entry.name, code=status_code, message=status_message if msg is None else msg)) (status_code, status_message) = self._get_status(self.projector_status) log.debug('({ip}) projector_status: {code}: "{message}"'.format(ip=self.entry.name, code=status_code, message=status_message if msg is None else msg)) (status_code, status_message) = self._get_status(self.error_status) log.debug('({ip}) error_status: {code}: "{message}"'.format(ip=self.entry.name, code=status_code, message=status_message if msg is None else msg)) # Now that we logged extra information for debugging, broadcast the original change/message # Check for connection errors first if self.error_status != S_OK: log.debug('({ip}) Signalling error code'.format(ip=self.entry.name)) code, message = self._get_status(self.error_status) status = self.error_status else: log.debug('({ip}) Signalling status code'.format(ip=self.entry.name)) code, message = self._get_status(status) if msg is not None: message = msg elif message is None: # No message for status code message = translate('OpenLP.PJLink', 'No message') if msg is None else msg self.changeStatus.emit(self.ip, status, message) self.projectorUpdateIcons.emit() @QtCore.pyqtSlot() def check_login(self, data=None): """ Processes the initial connection and convert to a PJLink packet if valid initial connection :param data: Optional data if called from another routine """ log.debug('({ip}) check_login(data="{data}")'.format(ip=self.entry.name, data=data)) if data is None: # Reconnected setup? if not self.waitForReadyRead(2000): # Possible timeout issue log.error('({ip}) Socket timeout waiting for login'.format(ip=self.entry.name)) self.change_status(E_SOCKET_TIMEOUT) return read = self.readLine(self.max_size) self.readLine(self.max_size) # Clean out any trailing whitespace if read is None: log.warning('({ip}) read is None - socket error?'.format(ip=self.entry.name)) return elif len(read) < 8: log.warning('({ip}) Not enough data read - skipping'.format(ip=self.entry.name)) return data = decode(read, 'utf-8') # Possibility of extraneous data on input when reading. # Clean out extraneous characters in buffer. self.read(1024) log.debug('({ip}) check_login() read "{data}"'.format(ip=self.entry.name, data=data.strip())) # At this point, we should only have the initial login prompt with # possible authentication # PJLink initial login will be: # 'PJLink 0' - Unauthenticated login - no extra steps required. # 'PJLink 1 XXXXXX' Authenticated login - extra processing required. if not data.startswith('PJLINK'): # Invalid initial packet - close socket log.error('({ip}) Invalid initial packet received - closing socket'.format(ip=self.entry.name)) return self.disconnect_from_host() # Convert the initial login prompt with the expected PJLink normal command format for processing log.debug('({ip}) check_login(): Formatting initial connection prompt ' 'to PJLink packet'.format(ip=self.entry.name)) return self.get_data('{start}{clss}{data}'.format(start=PJLINK_PREFIX, clss='1', data=data.replace(' ', '=', 1)).encode('utf-8')) def _trash_buffer(self, msg=None): """ Clean out extraneous stuff in the buffer. """ log.debug('({ip}) Cleaning buffer - msg = "{message}"'.format(ip=self.entry.name, message=msg)) if msg is None: msg = 'Invalid packet' log.warning('({ip}) {message}'.format(ip=self.entry.name, message=msg)) self.send_busy = False trash_count = 0 while self.bytesAvailable() > 0: trash = self.read(self.max_size) trash_count += len(trash) log.debug('({ip}) Finished cleaning buffer - {count} bytes dropped'.format(ip=self.entry.name, count=trash_count)) return @QtCore.pyqtSlot(QtNetwork.QHostAddress, int, str, name='udp_data') # host, port, data def get_buffer(self, host, port, data): """ Get data from somewhere other than TCP socket :param host: QHostAddress of sender :param port: Destination port :param data: Data to process. buffer must be formatted as a proper PJLink packet. """ if (port == int(self.port)) and (host.isEqual(self.qhost)): log.debug('({ip}) Received data from {host}'.format(ip=self.entry.name, host=host.toString())) log.debug('({ip}) get_buffer(data="{buff}")'.format(ip=self.entry.name, buff=data)) return self.get_data(buff=data) else: log.debug('({ip}) Ignoring data for {host} - not me'.format(ip=self.entry.name, host=host.toString())) @QtCore.pyqtSlot() def get_socket(self): """ Get data from TCP socket. """ log.debug('({ip}) get_socket(): Reading data'.format(ip=self.entry.name)) if QSOCKET_STATE[self.state()] != S_CONNECTED: log.debug('({ip}) get_socket(): Not connected - returning'.format(ip=self.entry.name)) self.send_busy = False return # Although we have a packet length limit, go ahead and use a larger buffer self.socket_timer.start() while self.bytesAvailable() >= 1: data = self.readLine(1024) data = data.strip() if not data: log.warning('({ip}) get_socket(): Ignoring empty packet'.format(ip=self.entry.name)) if self.bytesAvailable() < 1: break self.socket_timer.stop() if data: log.debug('({ip}) get_socket(): "{buff}"'.format(ip=self.entry.name, buff=data)) if data == -1: # No data available log.debug('({ip}) get_socket(): No data available (-1)'.format(ip=self.entry.name)) return return self.get_data(buff=data) def get_data(self, buff, *args, **kwargs): """ Process received data :param buff: Data to process. """ log.debug('({ip}) get_data(buffer="{buff}"'.format(ip=self.entry.name, buff=buff)) ignore_class = 'ignore_class' in kwargs # NOTE: Class2 has changed to some values being UTF-8 data_in = decode(buff, 'utf-8') if isinstance(buff, bytes) else buff data = data_in.strip() self.receive_data_signal() # Initial packet checks if len(data) < 7: self._trash_buffer(msg='get_data(): Invalid packet - length') return elif len(data) > self.max_size: self._trash_buffer(msg='get_data(): Invalid packet - too long ({length} bytes)'.format(length=len(data))) return elif not data.startswith(PJLINK_PREFIX): self._trash_buffer(msg='get_data(): Invalid packet - PJLink prefix missing') return elif data[6] != '=' and data[8] != '=': # data[6] = standard command packet # data[8] = initial PJLink connection (after mangling) self._trash_buffer(msg='get_data(): Invalid reply - Does not have "="') return log.debug('({ip}) get_data(): Checking new data "{data}"'.format(ip=self.entry.name, data=data)) header, data = data.split('=') log.debug('({ip}) get_data() header="{header}" data="{data}"'.format(ip=self.entry.name, header=header, data=data)) # At this point, the header should contain: # "PVCCCC" # Where: # P = PJLINK_PREFIX # V = PJLink class or version # C = PJLink command version, cmd = header[1], header[2:].upper() log.debug('({ip}) get_data() version="{version}" cmd="{cmd}" data="{data}"'.format(ip=self.entry.name, version=version, cmd=cmd, data=data)) if cmd not in PJLINK_VALID_CMD: self._trash_buffer('get_data(): Invalid packet - unknown command "{data}"'.format(data=cmd)) return elif version not in PJLINK_VALID_CMD[cmd]['version']: self._trash_buffer(msg='get_data() Command reply version does not match a valid command version') return elif int(self.pjlink_class) < int(version): if not ignore_class: log.warning('({ip}) get_data(): Projector returned class reply higher ' 'than projector stated class'.format(ip=self.entry.name)) return chk = process_command(self, cmd, data) if chk is None: # Command processed normally and not initial connection, so skip other checks return # PJLink initial connection checks elif chk == S_DATA_OK: # Previous command returned OK log.debug('({ip}) OK returned - resending command'.format(ip=self.entry.name)) self.send_command(cmd=cmd, priority=True) elif chk == S_CONNECT: # Normal connection log.debug('({ip}) Connecting normal'.format(ip=self.entry.name)) self.change_status(S_CONNECTED) self.send_command(cmd='CLSS', priority=True) self.readyRead.connect(self.get_socket) elif chk == S_AUTHENTICATE: # Connection with pin log.debug('({ip}) Connecting with pin'.format(ip=self.entry.name)) data_hash = str(qmd5_hash(salt=chk[1].encode('utf-8'), data=self.pin.encode('utf-8')), encoding='ascii') self.change_status(S_CONNECTED) self.readyRead.connect(self.get_socket) self.send_command(cmd='CLSS', salt=data_hash, priority=True) elif chk == E_AUTHENTICATION: # Projector did not like our pin log.warning('({ip}) Failed authentication - disconnecting'.format(ip=self.entry.name)) self.disconnect_from_host() self.projectorAuthentication.emit(self.entry.name) self.change_status(status=E_AUTHENTICATION) return @QtCore.pyqtSlot(QtNetwork.QAbstractSocket.SocketError) def get_error(self, err): """ Process error from SocketError signal. Remaps system error codes to projector error codes. :param err: Error code """ log.debug('({ip}) get_error(err={error}): {data}'.format(ip=self.entry.name, error=err, data=self.errorString())) if err <= 18: # QSocket errors. Redefined in projector.constants so we don't mistake # them for system errors check = err + E_CONNECTION_REFUSED self.poll_timer.stop() else: check = err if check < E_GENERAL: # Some system error? self.change_status(err, self.errorString()) else: self.change_status(E_NETWORK, self.errorString()) self.projectorUpdateIcons.emit() if self.status_connect == E_NOT_CONNECTED: self.abort() self.reset_information() return def send_command(self, cmd, opts='?', salt=None, priority=False): """ Add command to output queue if not already in queue. :param cmd: Command to send :param opts: Command option (if any) - defaults to '?' (get information) :param salt: Optional salt for md5 hash initial authentication :param priority: Option to send packet now rather than queue it up """ log.debug('({ip}) send_command(cmd="{cmd}" opts="{opts}" salt="{salt}" ' 'priority={pri}'.format(ip=self.entry.name, cmd=cmd, opts=opts, salt=salt, pri=priority)) if QSOCKET_STATE[self.state()] != S_CONNECTED: log.warning('({ip}) send_command(): Not connected - returning'.format(ip=self.entry.name)) return self.reset_information() if cmd not in PJLINK_VALID_CMD: log.error('({ip}) send_command(): Invalid command requested - ignoring.'.format(ip=self.entry.name)) if self.priority_queue or self.send_queue: # Just in case there's already something to send return self._send_command() return log.debug('({ip}) send_command(): Building cmd="{command}" opts="{data}" ' '{salt}'.format(ip=self.entry.name, command=cmd, data=opts, salt='' if salt is None else 'with hash')) # Until we absolutely have to start doing version checks, use the default # for PJLink class header = PJLINK_HEADER.format(linkclass=PJLINK_VALID_CMD[cmd]['default']) out = '{salt}{header}{command} {options}{suffix}'.format(salt="" if salt is None else salt, header=header, command=cmd, options=opts, suffix=PJLINK_SUFFIX) if out in self.priority_queue: log.warning('({ip}) send_command(): Already in priority queue - skipping'.format(ip=self.entry.name)) elif out in self.send_queue: log.warning('({ip}) send_command(): Already in normal queue - skipping'.format(ip=self.entry.name)) else: if priority: log.debug('({ip}) send_command(): Adding to priority queue'.format(ip=self.entry.name)) self.priority_queue.append(out) else: log.debug('({ip}) send_command(): Adding to normal queue'.format(ip=self.entry.name)) self.send_queue.append(out) if self.priority_queue or self.send_queue: # May be some initial connection setup so make sure we send data self._send_command() @QtCore.pyqtSlot() def _send_command(self, data=None, utf8=False): """ Socket interface to send data. If data=None, then check queue. :param data: Immediate data to send (Optional) :param utf8: Send as UTF-8 string otherwise send as ASCII string """ if not data and not self.priority_queue and not self.send_queue: log.warning('({ip}) _send_command(): Nothing to send - returning'.format(ip=self.entry.name)) self.send_busy = False return log.debug('({ip}) _send_command(data="{data}")'.format(ip=self.entry.name, data=data.strip() if data else data)) log.debug('({ip}) _send_command(): priority_queue: {queue}'.format(ip=self.entry.name, queue=self.priority_queue)) log.debug('({ip}) _send_command(): send_queue: {queue}'.format(ip=self.entry.name, queue=self.send_queue)) conn_state = STATUS_CODE[QSOCKET_STATE[self.state()]] log.debug('({ip}) _send_command(): Connection status: {data}'.format(ip=self.entry.name, data=conn_state)) if QSOCKET_STATE[self.state()] != S_CONNECTED: log.warning('({ip}) _send_command() Not connected - abort'.format(ip=self.entry.name)) self.send_busy = False return self.disconnect_from_host() if data and data not in self.priority_queue: log.debug('({ip}) _send_command(): Priority packet - adding to priority queue'.format(ip=self.entry.name)) self.priority_queue.append(data) if self.send_busy: # Still waiting for response from last command sent log.debug('({ip}) _send_command(): Still busy, returning'.format(ip=self.entry.name)) log.debug('({ip}) _send_command(): Priority queue = {data}'.format(ip=self.entry.name, data=self.priority_queue)) log.debug('({ip}) _send_command(): Normal queue = {data}'.format(ip=self.entry.name, data=self.send_queue)) return if not self.priority_queue and not self.send_queue: # No data to send log.warning('({ip}) _send_command(): No data to send'.format(ip=self.entry.name)) self.send_busy = False return elif self.priority_queue: out = self.priority_queue.pop(0) log.debug('({ip}) _send_command(): Getting priority queued packet'.format(ip=self.entry.name)) elif self.send_queue: out = self.send_queue.pop(0) log.debug('({ip}) _send_command(): Getting normal queued packet'.format(ip=self.entry.name)) self.send_busy = True log.debug('({ip}) _send_command(): Sending "{data}"'.format(ip=self.entry.name, data=out.strip())) self.socket_timer.start() sent = self.write(out.encode('{string_encoding}'.format(string_encoding='utf-8' if utf8 else 'ascii'))) self.waitForBytesWritten(2000) # 2 seconds should be enough if sent == -1: # Network error? self.change_status(E_NETWORK, translate('OpenLP.PJLink', 'Error while sending data to projector')) log.warning('({ip}) _send_command(): -1 received - disconnecting from host'.format(ip=self.entry.name)) self.disconnect_from_host() def connect_to_host(self): """ Initiate connection to projector. """ log.debug('({ip}) connect_to_host(): Starting connection'.format(ip=self.entry.name)) if QSOCKET_STATE[self.state()] == S_CONNECTED: log.warning('({ip}) connect_to_host(): Already connected - returning'.format(ip=self.entry.name)) return self.error_status = S_OK self.change_status(S_CONNECTING) self.connectToHost(self.ip, self.port) @QtCore.pyqtSlot() def disconnect_from_host(self, abort=False): """ Close socket and cleanup. """ if abort or QSOCKET_STATE[self.state()] != S_NOT_CONNECTED: if abort: log.warning('({ip}) disconnect_from_host(): Aborting connection'.format(ip=self.entry.name)) self.abort() else: log.warning('({ip}) disconnect_from_host(): Not connected'.format(ip=self.entry.name)) try: self.readyRead.disconnect(self.get_socket) except TypeError: # Since we already know what's happening, just log it for reference. log.debug('({ip}) disconnect_from_host(): Issue detected with ' 'readyRead.disconnect'.format(ip=self.entry.name)) log.debug('({ip}) disconnect_from_host(): ' 'Current status {data}'.format(ip=self.entry.name, data=self._get_status(self.status_connect)[0])) self.disconnectFromHost() if abort: self.change_status(E_NOT_CONNECTED) else: self.change_status(S_NOT_CONNECTED) self.reset_information() def get_av_mute_status(self, priority=False): """ Send command to retrieve shutter status. """ log.debug('({ip}) Sending AVMT command'.format(ip=self.entry.name)) return self.send_command(cmd='AVMT', priority=priority) def get_available_inputs(self): """ Send command to retrieve available source inputs. """ log.debug('({ip}) Sending INST command'.format(ip=self.entry.name)) return self.send_command(cmd='INST') def get_error_status(self): """ Send command to retrieve currently known errors. """ log.debug('({ip}) Sending ERST command'.format(ip=self.entry.name)) return self.send_command(cmd='ERST') def get_input_source(self): """ Send command to retrieve currently selected source input. """ log.debug('({ip}) Sending INPT command'.format(ip=self.entry.name)) return self.send_command(cmd='INPT') def get_lamp_status(self): """ Send command to return the lap status. """ log.debug('({ip}) Sending LAMP command'.format(ip=self.entry.name)) return self.send_command(cmd='LAMP') def get_manufacturer(self): """ Send command to retrieve manufacturer name. """ log.debug('({ip}) Sending INF1 command'.format(ip=self.entry.name)) return self.send_command(cmd='INF1') def get_model(self): """ Send command to retrieve the model name. """ log.debug('({ip}) Sending INF2 command'.format(ip=self.entry.name)) return self.send_command(cmd='INF2') def get_name(self): """ Send command to retrieve name as set by end-user (if set). """ log.debug('({ip}) Sending NAME command'.format(ip=self.entry.name)) return self.send_command(cmd='NAME') def get_other_info(self): """ Send command to retrieve extra info set by manufacturer. """ log.debug('({ip}) Sending INFO command'.format(ip=self.entry.name)) return self.send_command(cmd='INFO') def get_power_status(self, priority=False): """ Send command to retrieve power status. :param priority: (OPTIONAL) Send in priority queue """ log.debug('({ip}) Sending POWR command'.format(ip=self.entry.name)) return self.send_command(cmd='POWR', priority=priority) def set_audio_mute(self, priority=False): """ Send command to set audio to muted """ log.debug('({ip}) Setting AVMT to 21 (audio mute)'.format(ip=self.entry.name)) self.send_command(cmd='AVMT', opts='21', priority=True) self.status_timer_add(cmd='AVMT', callback=self.get_av_mute_status) self.poll_loop() def set_audio_normal(self, priority=False): """ Send command to set audio to normal """ log.debug('({ip}) Setting AVMT to 20 (audio normal)'.format(ip=self.entry.name)) self.send_command(cmd='AVMT', opts='20', priority=True) self.status_timer_add(cmd='AVMT', callback=self.get_av_mute_status) self.poll_loop() def set_input_source(self, src=None): """ Verify input source available as listed in 'INST' command, then send the command to select the input source. :param src: Video source to select in projector """ log.debug('({ip}) set_input_source(src="{data}")'.format(ip=self.entry.name, data=src)) if self.source_available is None: return elif src not in self.source_available: return log.debug('({ip}) Setting input source to "{data}"'.format(ip=self.entry.name, data=src)) self.send_command(cmd='INPT', opts=src, priority=True) self.poll_loop() def set_power_on(self): """ Send command to turn power to on. """ log.debug('({ip}) Setting POWR to 1 (on)'.format(ip=self.entry.name)) self.send_command(cmd='POWR', opts='1', priority=True) self.status_timer_add(cmd='POWR', callback=self.get_power_status) self.poll_loop() def set_power_off(self): """ Send command to turn power to standby. """ log.debug('({ip}) Setting POWR to 0 (standby)'.format(ip=self.entry.name)) self.send_command(cmd='POWR', opts='0', priority=True) self.status_timer_add(cmd='POWR', callback=self.get_power_status) self.poll_loop() def set_shutter_closed(self): """ Send command to set shutter to closed position. """ log.debug('({ip}) Setting AVMT to 11 (shutter closed)'.format(ip=self.entry.name)) self.send_command(cmd='AVMT', opts='11', priority=True) self.status_timer_add('AVMT', self.get_av_mute_status) self.poll_loop() def set_shutter_open(self): """ Send command to set shutter to open position. """ log.debug('({ip}) Setting AVMT to "10" (shutter open)'.format(ip=self.entry.name)) self.send_command(cmd='AVMT', opts='10', priority=True) self.status_timer_add('AVMT', self.get_av_mute_status) self.poll_loop() def status_timer_add(self, cmd, callback): """ Add a callback to the status timer. :param cmd: PJLink command associated with callback :param callback: Method to call """ if cmd in self.status_timer_checks: log.warning('({ip}) "{cmd}" already in checks - returning'.format(ip=self.entry.name, cmd=cmd)) return log.debug('({ip}) Adding "{cmd}" callback for status timer'.format(ip=self.entry.name, cmd=cmd)) self.status_timer_checks[cmd] = callback if not self.status_timer.isActive(): self.status_timer.start() def status_timer_delete(self, cmd): """ Delete a callback from the status timer. :param cmd: PJLink command associated with callback :param callback: Method to call """ if cmd not in self.status_timer_checks: log.warning('({ip}) "{cmd}" not listed in status timer - returning'.format(ip=self.entry.name, cmd=cmd)) return log.debug('({ip}) Removing "{cmd}" from status timer'.format(ip=self.entry.name, cmd=cmd)) self.status_timer_checks.pop(cmd) if not self.status_timer_checks: self.status_timer.stop() def status_timer_update(self): """ Call methods defined in status_timer_checks for updates """ if not self.status_timer_checks: log.warning('({ip}) status_timer_update() called when no callbacks - ' 'Race condition?'.format(ip=self.entry.name)) self.status_timer.stop() return for cmd, callback in self.status_timer_checks.items(): log.debug('({ip}) Status update call for {cmd}'.format(ip=self.entry.name, cmd=cmd)) callback(priority=True) def receive_data_signal(self): """ Clear any busy flags and send data received signal """ self.send_busy = False self.projectorReceivedData.emit() return