# -*- coding: utf-8 -*- # vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4 ########################################################################## # OpenLP - Open Source Lyrics Projection # # ---------------------------------------------------------------------- # # Copyright (c) 2008-2019 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 import re from codecs import decode from PyQt5 import QtCore, QtNetwork from openlp.core.common import qmd5_hash from openlp.core.common.i18n import translate from openlp.core.common.settings import Settings 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_DEFAULT_CODES, PJLINK_ERRORS, PJLINK_ERST_DATA, \ PJLINK_ERST_STATUS, PJLINK_MAX_PACKET, PJLINK_PORT, PJLINK_POWR_STATUS, PJLINK_PREFIX, PJLINK_SUFFIX, \ PJLINK_VALID_CMD, PROJECTOR_STATE, QSOCKET_STATE, S_CONNECTED, S_CONNECTING, S_NOT_CONNECTED, S_OFF, S_OK, S_ON, \ S_STANDBY, 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 log.debug('(UDP:{port}) PJLinkUDP() Initialized'.format(port=self.port)) if 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=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 PJLinkCommands(object): """ Process replies from PJLink projector. """ # List of IP addresses and mac addresses found via UDP search command ackn_list = [] def __init__(self, *args, **kwargs): """ Setup for the process commands """ log.debug('PJlinkCommands(args={args} kwargs={kwargs})'.format(args=args, kwargs=kwargs)) super().__init__() # Map PJLink command to method and include pjlink class version for this instance # Default initial pjlink class version is '1' self.pjlink_functions = { 'ACKN': {"method": self.process_ackn, # Class 2 (command is SRCH) "version": "2"}, 'AVMT': {"method": self.process_avmt, "version": "1"}, 'CLSS': {"method": self.process_clss, "version": "1"}, 'ERST': {"method": self.process_erst, "version": "1"}, 'INFO': {"method": self.process_info, "version": "1"}, 'INF1': {"method": self.process_inf1, "version": "1"}, 'INF2': {"method": self.process_inf2, "version": "1"}, 'INPT': {"method": self.process_inpt, "version": "1"}, 'INST': {"method": self.process_inst, "version": "1"}, 'LAMP': {"method": self.process_lamp, "version": "1"}, 'LKUP': {"method": self.process_lkup, # Class 2 (reply only - no cmd) "version": "2"}, 'NAME': {"method": self.process_name, "version": "1"}, 'PJLINK': {"method": self.process_pjlink, "version": "1"}, 'POWR': {"method": self.process_powr, "version": "1"}, 'SNUM': {"method": self.process_snum, "version": "1"}, 'SRCH': {"method": self.process_srch, # Class 2 (reply is ACKN) "version": "2"}, 'SVER': {"method": self.process_sver, "version": "1"}, 'RFIL': {"method": self.process_rfil, "version": "1"}, 'RLMP': {"method": self.process_rlmp, "version": "1"} } 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_name = None # NAME self.power = S_OFF # POWR 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 = [] # Reset default version in command routing dict for cmd in self.pjlink_functions: self.pjlink_functions[cmd]["version"] = PJLINK_VALID_CMD[cmd]['default'] def process_command(self, cmd, data): """ Verifies any return error code. Calls the appropriate command handler. :param cmd: Command to process :param data: Data being processed """ log.debug('({ip}) Processing command "{cmd}" with data "{data}"'.format(ip=self.entry.name, cmd=cmd, data=data)) # cmd should already be in uppercase, but data may be in mixed-case. # Due to some replies should stay as mixed-case, validate using separate uppercase check _data = data.upper() # Check if we have a future command not available yet if cmd not in self.pjlink_functions: log.warning('({ip}) Unable to process command="{cmd}" (Future option?)'.format(ip=self.entry.name, cmd=cmd)) return elif _data == 'OK': log.debug('({ip}) Command "{cmd}" returned OK'.format(ip=self.entry.name, cmd=cmd)) # A command returned successfully, so do a query on command to verify status return self.send_command(cmd=cmd) elif _data in PJLINK_ERRORS: # Oops - projector error log.error('({ip}) {cmd}: {err}'.format(ip=self.entry.name, cmd=cmd, err=STATUS_MSG[PJLINK_ERRORS[_data]])) if PJLINK_ERRORS[_data] == E_AUTHENTICATION: self.disconnect_from_host() self.projectorAuthentication.emit(self.name) return self.change_status(status=E_AUTHENTICATION) # Command checks already passed log.debug('({ip}) Calling function for {cmd}'.format(ip=self.entry.name, cmd=cmd)) self.pjlink_functions[cmd]["method"](data=data) def process_ackn(self, data): """ Process the ACKN command. :param data: Data in packet """ # TODO: Have to rethink this one pass def process_avmt(self, data): """ Process shutter and speaker status. See PJLink specification for format. Update self.mute (audio) and self.shutter (video shutter). 10 = Shutter open, audio unchanged 11 = Shutter closed, audio unchanged 20 = Shutter unchanged, Audio normal 21 = Shutter unchanged, Audio muted 30 = Shutter open, audio muted 31 = Shutter closed, audio normal :param data: Shutter and audio status """ settings = {'10': {'shutter': False, 'mute': self.mute}, '11': {'shutter': True, 'mute': self.mute}, '20': {'shutter': self.shutter, 'mute': False}, '21': {'shutter': self.shutter, 'mute': True}, '30': {'shutter': False, 'mute': False}, '31': {'shutter': True, 'mute': True} } if data not in settings: log.warning('({ip}) Invalid shutter response: {data}'.format(ip=self.entry.name, data=data)) return shutter = settings[data]['shutter'] mute = settings[data]['mute'] # Check if we need to update the icons update_icons = (shutter != self.shutter) or (mute != self.mute) self.shutter = shutter self.mute = mute if update_icons: if 'AVMT' in self.status_timer_checks: self.status_timer_delete('AVMT') self.projectorUpdateIcons.emit() return def process_clss(self, data): """ PJLink class that this projector supports. See PJLink specification for format. Updates self.class. :param data: Class that projector supports. """ # bug 1550891: Projector returns non-standard class response: # : Expected: '%1CLSS=1' # : Received: '%1CLSS=Class 1' (Optoma) # : Received: '%1CLSS=Version1' (BenQ) if len(data) > 1: log.warning('({ip}) Non-standard CLSS reply: "{data}"'.format(ip=self.entry.name, data=data)) # Due to stupid projectors not following standards (Optoma, BenQ comes to mind), # AND the different responses that can be received, the semi-permanent way to # fix the class reply is to just remove all non-digit characters. chk = re.findall(r'\d', data) if len(chk) < 1: log.error('({ip}) No numbers found in class version reply "{data}" - ' 'defaulting to class "1"'.format(ip=self.entry.name, data=data)) clss = '1' else: clss = chk[0] # Should only be the first match elif not data.isdigit(): log.error('({ip}) NAN CLSS version reply "{data}" - ' 'defaulting to class "1"'.format(ip=self.entry.name, data=data)) clss = '1' else: clss = data self.pjlink_class = clss log.debug('({ip}) Setting pjlink_class for this projector ' 'to "{data}"'.format(ip=self.entry.name, data=self.pjlink_class)) # Update method class versions for cmd in self.pjlink_functions: if self.pjlink_class in PJLINK_VALID_CMD[cmd]['version']: self.pjlink_functions[cmd]['version'] = self.pjlink_class # Since we call this one on first connect, setup polling from here if not self.no_poll: log.debug('({ip}) process_pjlink(): Starting timer'.format(ip=self.entry.name)) self.poll_timer.setInterval(1000) # Set 1 second for initial information self.poll_timer.start() return def process_erst(self, data): """ Error status. See PJLink Specifications for format. Updates self.projector_errors :param data: Error status """ if len(data) != PJLINK_ERST_DATA['DATA_LENGTH']: count = PJLINK_ERST_DATA['DATA_LENGTH'] log.warning('({ip}) Invalid error status response "{data}": ' 'length != {count}'.format(ip=self.entry.name, data=data, count=count)) return try: datacheck = int(data) except ValueError: # Bad data - ignore log.warning('({ip}) Invalid error status response "{data}"'.format(ip=self.entry.name, data=data)) return if datacheck == 0: self.projector_errors = None # No errors return # We have some sort of status error, so check out what it/they are self.projector_errors = {} fan, lamp, temp, cover, filt, other = (data[PJLINK_ERST_DATA['FAN']], data[PJLINK_ERST_DATA['LAMP']], data[PJLINK_ERST_DATA['TEMP']], data[PJLINK_ERST_DATA['COVER']], data[PJLINK_ERST_DATA['FILTER']], data[PJLINK_ERST_DATA['OTHER']]) if fan != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Fan')] = \ PJLINK_ERST_STATUS[fan] if lamp != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Lamp')] = \ PJLINK_ERST_STATUS[lamp] if temp != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Temperature')] = \ PJLINK_ERST_STATUS[temp] if cover != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Cover')] = \ PJLINK_ERST_STATUS[cover] if filt != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Filter')] = \ PJLINK_ERST_STATUS[filt] if other != PJLINK_ERST_STATUS[S_OK]: self.projector_errors[translate('OpenLP.ProjectorPJLink', 'Other')] = \ PJLINK_ERST_STATUS[other] return def process_inf1(self, data): """ Manufacturer name set in projector. Updates self.manufacturer :param data: Projector manufacturer """ self.manufacturer = data log.debug('({ip}) Setting projector manufacturer data to "{data}"'.format(ip=self.entry.name, data=self.manufacturer)) return def process_inf2(self, data): """ Projector Model set in projector. Updates self.model. :param data: Model name """ self.model = data log.debug('({ip}) Setting projector model to "{data}"'.format(ip=self.entry.name, data=self.model)) return def process_info(self, data): """ Any extra info set in projector. Updates self.other_info. :param data: Projector other info """ self.other_info = data log.debug('({ip}) Setting projector other_info to "{data}"'.format(ip=self.entry.name, data=self.other_info)) return def process_inpt(self, data): """ Current source input selected. See PJLink specification for format. Update self.source :param data: Currently selected source """ # First, see if we have a valid input based on what is installed (if available) if self.source_available is not None: # We have available inputs, so verify it's in the list if data not in self.source_available: log.warn('({ip}) Input source not listed in available sources - ignoring'.format(ip=self.entry.name)) return elif data not in PJLINK_DEFAULT_CODES: # Hmm - no sources available yet, so check with PJLink defaults log.warn('({ip}) Input source not listed as a PJLink available source ' '- ignoring'.format(ip=self.entry.name)) return self.source = data log.debug('({ip}) Setting data source to "{data}"'.format(ip=self.entry.name, data=self.source)) return def process_inst(self, data): """ Available source inputs. See PJLink specification for format. Updates self.source_available :param data: Sources list """ sources = [] check = data.split() for source in check: sources.append(source) sources.sort() self.source_available = sources log.debug('({ip}) Setting projector source_available to "{data}"'.format(ip=self.entry.name, data=self.source_available)) self.projectorUpdateIcons.emit() return def process_lamp(self, data): """ Lamp(s) status. See PJLink Specifications for format. Data may have more than 1 lamp to process. Update self.lamp dictionary with lamp status. :param data: Lamp(s) status. """ lamps = [] lamp_list = data.split() if len(lamp_list) < 2: lamps.append({'Hours': int(lamp_list[0]), 'On': None}) else: while lamp_list: try: fill = {'Hours': int(lamp_list[0]), 'On': False if lamp_list[1] == '0' else True} except ValueError: # In case of invalid entry log.warning('({ip}) process_lamp(): Invalid data "{data}"'.format(ip=self.entry.name, data=data)) return lamps.append(fill) lamp_list.pop(0) # Remove lamp hours lamp_list.pop(0) # Remove lamp on/off self.lamp = lamps return def process_lkup(self, data): """ Process reply indicating remote is available for connection :param data: Data packet from remote """ log.debug('({ip}) Processing LKUP command'.format(ip=self.entry.name)) if Settings().value('projector/connect when LKUP received'): self.connect_to_host() def process_name(self, data): """ Projector name set in projector. Updates self.pjlink_name :param data: Projector name """ self.pjlink_name = data log.debug('({ip}) Setting projector PJLink name to "{data}"'.format(ip=self.entry.name, data=self.pjlink_name)) return def process_pjlink(self, data): """ Process initial socket connection to terminal. :param data: Initial packet with authentication scheme """ log.debug('({ip}) Processing PJLINK command'.format(ip=self.entry.name)) chk = data.split(' ') if len(chk[0]) != 1: # Invalid - after splitting, first field should be 1 character, either '0' or '1' only log.error('({ip}) Invalid initial authentication scheme - aborting'.format(ip=self.entry.name)) return self.disconnect_from_host() elif chk[0] == '0': # Normal connection no authentication if len(chk) > 1: # Invalid data - there should be nothing after a normal authentication scheme log.error('({ip}) Normal connection with extra information - aborting'.format(ip=self.entry.name)) return self.disconnect_from_host() elif self.pin: log.error('({ip}) Normal connection but PIN set - aborting'.format(ip=self.entry.name)) return self.disconnect_from_host() else: data_hash = None elif chk[0] == '1': if len(chk) < 2: # Not enough information for authenticated connection log.error('({ip}) Authenticated connection but not enough info - aborting'.format(ip=self.entry.name)) return self.disconnect_from_host() elif not self.pin: log.error('({ip}) Authenticate connection but no PIN - aborting'.format(ip=self.entry.name)) return self.disconnect_from_host() else: data_hash = str(qmd5_hash(salt=chk[1].encode('utf-8'), data=self.pin.encode('utf-8')), encoding='ascii') # Passed basic checks, so start connection self.readyRead.connect(self.get_socket) self.change_status(S_CONNECTED) log.debug('({ip}) process_pjlink(): Sending "CLSS" initial command'.format(ip=self.entry.name)) # Since this is an initial connection, make it a priority just in case return self.send_command(cmd="CLSS", salt=data_hash, priority=True) def process_powr(self, data): """ Power status. See PJLink specification for format. Update self.power with status. Update icons if change from previous setting. :param data: Power status """ log.debug('({ip}: Processing POWR command'.format(ip=self.entry.name)) if data in PJLINK_POWR_STATUS: power = PJLINK_POWR_STATUS[data] update_icons = self.power != power self.power = power self.change_status(PJLINK_POWR_STATUS[data]) if update_icons: self.projectorUpdateIcons.emit() # Update the input sources available if power == S_ON: self.send_command('INST') else: # Log unknown status response log.warning('({ip}) Unknown power response: "{data}"'.format(ip=self.entry.name, data=data)) if self.power in [S_ON, S_STANDBY, S_OFF] and 'POWR' in self.status_timer_checks: self.status_timer_delete(cmd='POWR') return def process_rfil(self, data): """ Process replacement filter type """ if self.model_filter is None: self.model_filter = data else: log.warning('({ip}) Filter model already set'.format(ip=self.entry.name)) log.warning('({ip}) Saved model: "{old}"'.format(ip=self.entry.name, old=self.model_filter)) log.warning('({ip}) New model: "{new}"'.format(ip=self.entry.name, new=data)) def process_rlmp(self, data): """ Process replacement lamp type """ if self.model_lamp is None: self.model_lamp = data else: log.warning('({ip}) Lamp model already set'.format(ip=self.entry.name)) log.warning('({ip}) Saved lamp: "{old}"'.format(ip=self.entry.name, old=self.model_lamp)) log.warning('({ip}) New lamp: "{new}"'.format(ip=self.entry.name, new=data)) def process_snum(self, data): """ Serial number of projector. :param data: Serial number from projector. """ if self.serial_no is None: log.debug('({ip}) Setting projector serial number to "{data}"'.format(ip=self.entry.name, data=data)) self.serial_no = data self.db_update = False else: # Compare serial numbers and see if we got the same projector if self.serial_no != data: log.warning('({ip}) Projector serial number does not match saved serial ' 'number'.format(ip=self.entry.name)) log.warning('({ip}) Saved: "{old}"'.format(ip=self.entry.name, old=self.serial_no)) log.warning('({ip}) Received: "{new}"'.format(ip=self.entry.name, new=data)) log.warning('({ip}) NOT saving serial number'.format(ip=self.entry.name)) self.serial_no_received = data def process_srch(self, data): """ Process the SRCH command. SRCH is processed by terminals so we ignore any packet. :param data: Data in packet """ log.warning("({ip}) SRCH packet detected - ignoring".format(ip=self.entry.ip)) return def process_sver(self, data): """ Software version of projector """ if len(data) > 32: # Defined in specs max version is 32 characters log.warning('Invalid software version - too long') return elif self.sw_version is None: log.debug('({ip}) Setting projector software version to "{data}"'.format(ip=self.entry.name, data=data)) else: if self.sw_version != data: log.warning('({ip}) Projector software version does not match saved ' 'software version'.format(ip=self.entry.name)) log.warning('({ip}) Saved: "{old}"'.format(ip=self.entry.name, old=self.sw_version)) log.warning('({ip}) Received: "{new}"'.format(ip=self.entry.name, new=data)) log.warning('({ip}) Updating software version'.format(ip=self.entry.name)) self.sw_version = data self.db_update = True class PJLink(QtNetwork.QTcpSocket, PJLinkCommands): """ 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 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 read = self.readLine(1024) log.debug('({ip}) get_socket(): "{buff}"'.format(ip=self.entry.name, buff=read)) if read == -1: # No data available log.debug('({ip}) get_socket(): No data available (-1)'.format(ip=self.entry.name)) return self.receive_data_signal() self.socket_timer.stop() return self.get_data(buff=read) 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 if isinstance(buff, bytes): data_in = decode(buff, 'utf-8') else: data_in = buff data = data_in.strip() # Initial packet checks if (len(data) < 7): self._trash_buffer(msg='get_data(): Invalid packet - length') return self.receive_data_signal() elif len(data) > self.max_size: self._trash_buffer(msg='get_data(): Invalid packet - too long ({length} bytes)'.format(length=len(data))) return self.receive_data_signal() elif not data.startswith(PJLINK_PREFIX): self._trash_buffer(msg='get_data(): Invalid packet - PJLink prefix missing') return self.receive_data_signal() 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 self.receive_data_signal() 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}"'.format(ip=self.entry.name, version=version, cmd=cmd)) # TODO: Below commented for now since it seems to cause issues with testing some invalid data. # Revisit after more refactoring is finished. ''' try: version, cmd = header[1], header[2:].upper() log.debug('({ip}) get_data() version="{version}" cmd="{cmd}"'.format(ip=self.entry.name, version=version, cmd=cmd)) except ValueError as e: self.change_status(E_INVALID_DATA) log.warning('({ip}) get_data(): Received data: "{data}"'.format(ip=self.entry.name, data=data_in)) self._trash_buffer('get_data(): Expected header + command + data') return self.receive_data_signal() ''' if cmd not in PJLINK_VALID_CMD: self._trash_buffer('get_data(): Invalid packet - unknown command "{data}"'.format(data=cmd)) return self.receive_data_signal() 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 self.receive_data_signal() 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)) self.process_command(cmd, data) return self.receive_data_signal() @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 """ 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)) 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')) header = PJLINK_HEADER.format(linkclass=self.pjlink_functions[cmd]["version"]) 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.debug('({ip}) send_command(): Already in priority queue - skipping'.format(ip=self.entry.name)) elif out in self.send_queue: log.debug('({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.debug('({ip}) _send_command(): Nothing to send - returning'.format(ip=self.entry.name)) 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.debug('({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 len(self.priority_queue) != 0: out = self.priority_queue.pop(0) log.debug('({ip}) _send_command(): Getting priority queued packet'.format(ip=self.entry.name)) elif len(self.send_queue) != 0: out = self.send_queue.pop(0) log.debug('({ip}) _send_command(): Getting normal queued packet'.format(ip=self.entry.name)) else: # No data to send log.debug('({ip}) _send_command(): No data to send'.format(ip=self.entry.name)) self.send_busy = False return 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_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)) if not self.status_timer.isActive(): self.status_timer.start() self.status_timer_checks[cmd] = callback 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