import logging from backend import LrcException from backend.recorder_adapters import telnetlib, TelnetAdapter, RecorderAdapter from backend.tools.exception_decorator import exception_decorator logger = logging.getLogger("lrc.recorder_adapters.extron_smp") RECORDER_MODEL_NAME = "SMP 351 / 352" VERSION = "0.9.0" REQUIRES_USER = False REQUIRES_PW = True # HOST = "localhost" # HOST = "129.13.51.102" # Audimax SMP 351 # HOST = "129.13.51.106" # Tulla SMP 351 HOST = "172.22.246.207" # Test SMP MZ HOST = "129.13.51.109" # Hertz USER = "admin" PW = "123mzsmp" #PW = "audimaxsmp" PW = "smphertz" class SMP(TelnetAdapter, RecorderAdapter): def __init__(self, address, password, auto_login=True, **kwargs): super().__init__(address) self.admin_pw = password if auto_login: self._login() def _login(self): logger.debug("Connecting to {} ...".format(self.address)) try: self.tn = telnetlib.Telnet(self.address) except TimeoutError as e: raise LrcException(str(e)) except ConnectionRefusedError as e: raise LrcException(str(e)) self.tn.read_until("\r\nPassword:") # password = getpass.getpass() password = self.admin_pw self.tn.write(password + "\n\r") out = self.tn.assert_string_in_output("Login Administrator") print(out) if not out[0]: print(out[1]) if "Password:" in out[1]: # TODO: loop until logged in... logger.warning("Could not login (as admin) with given password! {}".format(self.address)) print("re-enter pw") self.tn.write(self.admin_pw+"\n\r") print(self.tn.assert_string_in_output("Login Administrator")) print("WRONG (admin) password!! Exiting!") print(self.admin_pw) self.tn = None logger.error("Could definitely not login (as admin) with given password! {}".format(self.address)) raise Exception("Could not login as administrator with given pw!") print("OK, we have admin rights!") def _get_name(self): return RECORDER_MODEL_NAME def _get_version(self): return VERSION def get_version(self, include_build=False, verbose_info=False): if verbose_info: self.tn.write("0Q") else: if include_build: self.tn.write("*Q\n") else: self.tn.write("1Q\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_bootstrap_version(self): self.tn.write("2Q") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_factory_firmware_version(self): self.tn.write("3Q") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_updated_firmware_version(self): self.tn.write("4Q") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_part_number(self): self.tn.write("N") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_model_name(self): self.tn.write("1I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_model_description(self): self.tn.write("2I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_system_memory_usage(self): self.tn.write("3I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_number_of_connected_users(self): self.tn.write("10I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_system_processer_usage(self): self.tn.write("11I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_system_processor_idle(self): self.tn.write("12I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_eth0_link_status(self): self.tn.write("13I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_file_transfer_config(self): self.tn.write("38I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_active_alarms(self): self.tn.write("39I") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_unit_name(self, name: str): # TODO: check name (must comply with internet host name standards) self.tn.write(self.esc_char + name + "CN\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_unit_name(self): self.tn.write(self.esc_char + " CN\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_unit_name(self): self.tn.write(self.esc_char + "CN\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_telnet_connections(self): self.tn.write(self.esc_char + "CC\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_verbose_mode(self, mode: int): """ Mode: 0=clear/none (default for telnet connections 1=verbose mode (default for USB and RS-232 host control) 2=tagged responses for queries 3=verbose mode and tagged responses for queries :param mode: :return: """ if mode not in range(4): raise Exception("Only values from 0 to 3 are allowed!") self.tn.write(self.esc_char + str(mode) + "CV\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_verbose_mode(self): self.tn.write(self.esc_char + "CV\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def save_configuration(self, mode: int = 2): """ Mode: 0 = IP config 2 = Box specific parameters :param mode: :return: """ if mode not in [0, 2]: raise Exception("Only values 0 and 2 are allowed!") self.tn.write(self.esc_char + "1*{}XF\n".format(mode)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def restore_configuration(self, mode: int = 2): """ Mode: 0 = IP config 2 = Box specific parameters :param mode: :return: """ if mode not in [0, 2]: raise Exception("Only values 0 and 2 are allowed!") self.tn.write(self.esc_char + "0*{}XF\n".format(mode)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reboot(self): self.tn.write(self.esc_char + "1BOOT\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def restart_network(self): self.tn.write(self.esc_char + "2BOOT\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_flash(self): """ Reset flash memory (excludes recording files). :return: """ self.tn.write(self.esc_char + "ZFFF\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def system_reset(self): """ Resets device to default and deletes recorded files :return: """ self.tn.write(self.esc_char + "ZXXX\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_settings_and_delete_all_files(self): """ Reset to default except IP address, delete all user and recorded files :return: """ self.tn.write(self.esc_char + "ZY\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def absolute_reset(self): """ Same as System Reset, plus returns the IP address and subnet mask to defaults. :return: """ self.tn.write(self.esc_char + "ZQQQ\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_front_panel_lock(self, mode: int): """ 0=Off 1=complete lockout (no front panel control) 2=menu lockout 3=recording controls :param mode: Execute mode int code :return: """ if mode not in range(4): raise Exception("Only values from 0 to 3 are allowed!") self.tn.write(str(mode) + "X\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_front_panel_lock(self): """ View executive mode. 0=Off 1=complete lockout (no front panel control) 2=menu lockout 3=recording controls :return: """ self.tn.write("X\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) """ A lot of stuff related to network settings (ports of services, SNMP, IP, DHCP, etc.) Only some stuff will be implemented here! """ """ def get_date_time(self): pass def get_time_zone(self): pass def get_dhcp_mode(self): pass def get_network_settings(self): pass def get_ip_address(self): pass def get_mac_address(self): pass def get_subnet_mask(self): pass def get_gateway_ip(self): pass def get_dns_server_ip(self): pass """ """ RS-232 / serial port related stuff not implemented. Password and security related stuff not implemented. File related stuff not implemented. (-> use sftp) """ def set_input(self, input_num: int, channel_num: int): """ Switches input # (1 to 5) to output channel (1=A [input 1 and 2], 2=B [input 3, 4 and 5]) :param input_num: :param channel_num: :return: """ if input_num not in range(1, 6): raise Exception("input_num must be a value between 1 and 5!") if channel_num not in range(1, 3): raise Exception("input_num must be a value between 1 and 2!") self.tn.write("{}*{}!\n".format(input_num, channel_num)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input(self, channel_num: int): if channel_num not in range(1, 2): raise Exception("input_num must be a value between 1 and 2!") self.tn.write("{}!\n".format(channel_num)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_input_format(self, input_num: int, input_format: int): """ Sets the input to the format, where the input_format parameter may be: 1 = YUVp / HDTV (default) 2 = YUVi 3 = Composite :param input_num: :param input_format: :return: """ if input_num not in range(1, 6): raise Exception("input_num must be a value between 1 and 5!") if input_format not in range(1, 4): raise Exception("input_num must be a value between 1 and 3!") self.tn.write("{}*{}\\\n".format(input_num, input_format)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_format(self, input_num: int): if input_num not in range(1, 6): raise Exception("input_num must be a value between 1 and 5!") self.tn.write("{}\\\n".format(input_num)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_input_name(self, input_num: int, input_name: str): if input_num not in range(1, 6): raise Exception("input_num must be a value between 1 and 5!") if len(input_name) > 16: raise Exception("input_name must be no longer than 16 chars") try: input_name.encode('ascii') except UnicodeEncodeError: raise Exception("input_name must only contain ascii characters") self.tn.write("{}{},{}NI\n".format(self.esc_char, input_num, input_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_name(self, input_num: int): if input_num not in range(1, 6): raise Exception("input_num must be a value between 1 and 5!") self.tn.write("{}{}NI\n".format(self.esc_char, input_num)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_selction_per_channel(self): self.tn.write("32I\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) """ Input configuration part skipped """ def stop_recording(self): self.tn.write("{}Y0RCDR\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def start_recording(self): self.tn.write("{}Y1RCDR\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def pause_recording(self): self.tn.write("{}Y2RCDR\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) @exception_decorator(ConnectionError) def get_recording_status(self): """ Status may be one of: 0=stop 1=record 2=pause :return: status """ self.tn.write("{}YRCDR\n".format(self.esc_char)) return int(TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())) def is_recording(self) -> bool: return self.get_recording_status() == 1 def extent_recording_time(self, extension_time: int): """ Extends a scheduled recording by extension_time minutes :param extension_time: must be an int from 0 to 99 :return: """ if extension_time not in range(0, 100): raise Exception("extension_time must be a value between 0 and 99!") self.tn.write("{}E{}RCDR\n".format(self.esc_char, extension_time)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def add_chapter_marker(self): self.tn.write("{}BRCDR\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def swap_channel_positions(self): self.tn.write("%\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_recording_status_text(self): self.tn.write("I\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_elapsed_recording_time(self): self.tn.write("35I\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_remaining_recording_time(self): self.tn.write("36I\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_recording_destination(self): self.tn.write("37I\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) """ Metadata part skipped """ def recall_user_preset(self, channel_number: int, preset_number: int): if channel_number not in range(1, 3): raise Exception("channel_number must be a value between 1 and 2!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("1*{}*{}.\n".format(channel_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def save_user_preset(self, channel_number: int, preset_number: int): if channel_number not in range(1, 3): raise Exception("channel_number must be a value between 1 and 2!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("1*{}*{},\n".format(channel_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_user_preset_name(self, preset_number: int, preset_name: str): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") if len(preset_name) > 16: raise Exception("preset_name must be no longer than 16 chars") try: preset_name.encode('ascii') except UnicodeEncodeError: raise Exception("preset_name must only contain ascii characters") self.tn.write("{}1*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_user_preset_name(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}1*{}PNAM\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_user_presets(self, input_number: int): if input_number not in range(1, 6): raise Exception("input_number must be a value between 1 and 5!") self.tn.write("52*{}#\n".format(input_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) # Input Presets def recall_input_preset(self, channel_number: int, preset_number: int): if channel_number not in range(1, 3): raise Exception("channel_number must be a value between 1 and 2!") if preset_number not in range(1, 129): raise Exception("preset_number must be a value between 1 and 128!") self.tn.write("2*{}*{}.\n".format(channel_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def save_input_preset(self, channel_number: int, preset_number: int): if channel_number not in range(1, 3): raise Exception("channel_number must be a value between 1 and 2!") if preset_number not in range(1, 129): raise Exception("preset_number must be a value between 1 and 128!") self.tn.write("1*{}*{},\n".format(channel_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_input_preset_name(self, preset_number: int, preset_name: str): if preset_number not in range(1, 129): raise Exception("preset_number must be a value between 1 and 128!") if len(preset_name) > 16: raise Exception("preset_name must be no longer than 16 chars") try: preset_name.encode('ascii') except UnicodeEncodeError: raise Exception("preset_name must only contain ascii characters") self.tn.write("{}2*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_preset_name(self, preset_number: int): if preset_number not in range(1, 129): raise Exception("preset_number must be a value between 1 and 128!") self.tn.write("{}2*{}PNAM\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def delete_input_preset(self, preset_number: int): if preset_number not in range(1, 129): raise Exception("preset_number must be a value between 1 and 128!") self.tn.write("{}X2*{}PRST\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_presets(self): self.tn.write("51#\n") return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) # Streaming Presets def recall_streaming_preset(self, output_number: int, preset_number: int): """ Output_number: 1 = Channel A 2 = Channel B 3 = Confidence Stream :param preset_number: :param output_number: :return: """ if output_number not in range(1, 4): raise Exception("output_number must be a value between 1 and 3!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("3*{}*{}.\n".format(output_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def save_streaming_preset(self, output_number: int, preset_number: int): """ Output_number: 1 = Channel A 2 = Channel B 3 = Confidence Stream :param output_number: :param preset_number: :return: """ if output_number not in range(1, 4): raise Exception("output_number must be a value between 1 and 3!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("3*{}*{},\n".format(output_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_streaming_preset_name(self, preset_number: int, preset_name: str): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") if len(preset_name) > 16: raise Exception("preset_name must be no longer than 16 chars") try: preset_name.encode('ascii') except UnicodeEncodeError: raise Exception("preset_name must only contain ascii characters") self.tn.write("{}3*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_streaming_preset_name(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}3*{}PNAM\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_streaming_preset_to_default(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}X3*{}PRST\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) # Encoder Presets def recall_encoder_preset(self, output_number: int, preset_number: int): """ Output_number: 1 = Channel A 2 = Channel B 3 = Confidence Stream :param preset_number: :param output_number: :return: """ if output_number not in range(1, 4): raise Exception("output_number must be a value between 1 and 3!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("4*{}*{}.\n".format(output_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def save_encoder_preset(self, output_number: int, preset_number: int): """ Output_number: 1 = Channel A 2 = Channel B 3 = Confidence Stream :param preset_number: :param output_number: :return: """ if output_number not in range(1, 4): raise Exception("output_number must be a value between 1 and 3!") if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("4*{}*{},\n".format(output_number, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_encoder_preset_name(self, preset_number: int, preset_name: str): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") if len(preset_name) > 16: raise Exception("preset_name must be no longer than 16 chars") try: preset_name.encode('ascii') except UnicodeEncodeError: raise Exception("preset_name must only contain ascii characters") self.tn.write("{}4*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_encoder_preset_name(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}4*{}PNAM\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_encoder_preset_to_default(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}X4*{}PRST\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) # Layout Presets def save_layout_preset(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("7*{},\n".format(preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def recall_layout_preset(self, preset_number: int, include_input_selections: bool = True): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") if include_input_selections: self.tn.write("7*{}.\n".format(preset_number)) else: self.tn.write("8*{}.\n".format(preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_layout_preset_name(self, preset_number: int, preset_name: str): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") if len(preset_name) > 16: raise Exception("preset_name must be no longer than 16 chars") try: preset_name.encode('ascii') except UnicodeEncodeError: raise Exception("preset_name must only contain ascii characters") self.tn.write("{}7*{},{}PNAM\n".format(self.esc_char, preset_number, preset_name)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_layout_preset_name(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}7*{}PNAM\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def reset_layout_preset_to_default(self, preset_number: int): if preset_number not in range(1, 17): raise Exception("preset_number must be a value between 1 and 16!") self.tn.write("{}X7*{}PRST\n".format(self.esc_char, preset_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) """ Input adjustments skipped Picture adjustments skipped """ def mute_output(self, output_number: int): """ Output_number: 1 = Channel A 2 = Channel B :param output_number: :return: """ if output_number not in range(1, 3): raise Exception("output_number must be a value between 1 and 2!") self.tn.write("{}*1B\n".format(output_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def unmute_output(self, output_number: int): """ Output_number: 1 = Channel A 2 = Channel B :param output_number: :return: """ if output_number not in range(1, 3): raise Exception("output_number must be a value between 1 and 2!") self.tn.write("{}*0B\n".format(output_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def is_muted(self, output_number: int): """ Output_number: 1 = Channel A 2 = Channel B :param output_number: :return: """ if output_number not in range(1, 3): raise Exception("output_number must be a value between 1 and 2!") self.tn.write("{}B\n".format(output_number)) return int(TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line())) > 0 """ EDID skipped Encoder settings skipped some advanced options skipped """ def get_input_hdcp_status(self, input_number: int): """ returns: 0 = no sink / source detected 1 = sink / source detected with HDCP 2 = sink / source detected without HDCP :param input_number: from 1 to 5 :return: """ if input_number not in range(1, 6): raise Exception("input_number must be a value between 1 and 6!") self.tn.write("{}I{}HDCP\n".format(self.esc_char, input_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_input_authorization_hdcp_on(self, input_number: int): if input_number not in range(1, 6): raise Exception("input_number must be a value between 1 and 6!") self.tn.write("{}E{}*1HDCP\n".format(self.esc_char, input_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def set_input_authorization_hdcp_off(self, input_number: int): if input_number not in range(1, 6): raise Exception("input_number must be a value between 1 and 6!") self.tn.write("{}E{}*0HDCP\n".format(self.esc_char, input_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_input_authorization_hdcp_status(self, input_number: int): if input_number not in range(1, 6): raise Exception("input_number must be a value between 1 and 6!") self.tn.write("{}E{}HDCP\n".format(self.esc_char, input_number)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def enable_hdcp_notification(self): self.tn.write("{}N1HDCP\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def disable_hdcp_notification(self): self.tn.write("{}N0HDCP\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_hdcp_notification_status(self): self.tn.write("{}NHDCP\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) # background image settings def set_background_image(self, filename: str): self.tn.write("{}{}RF\n".format(self.esc_char, filename)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def get_background_image_filename(self): self.tn.write("{}RF\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def mute_background_image(self): self.tn.write("{}0RF\n".format(self.esc_char)) return TelnetAdapter._get_response_str(self.tn.read_until_non_empty_line()) def main(): smp = SMP(HOST, PW, True) print(smp) print(smp.get_recording_status()) print(smp.is_recording()) exit() smp._login() print(smp.get_version(verbose_info=False)) print(smp.get_file_transfer_config()) print(smp.save_configuration()) print(smp.restore_configuration()) return print(smp.get_bootstrap_version()) print(smp.get_part_number()) print(smp.get_model_name()) print(smp.get_model_description()) print(smp.get_system_memory_usage()) print(smp.get_file_transfer_config()) # print(smp.get_unit_name()) # print(smp.set_unit_name("mzsmp")) # print(smp.get_unit_name()) # print(smp.reset_unit_name()) print(smp.set_front_panel_lock(0)) print(smp.get_front_panel_lock()) print(smp.get_input_name(1)) print(smp.get_input_selction_per_channel()) print(smp.get_recording_status()) print("Preset Name: " + smp.get_user_preset_name(2)) print(smp.get_user_presets(1)) print(smp.get_input_presets()) print(smp.get_layout_preset_name(2)) print(smp.get_encoder_preset_name(1)) print(smp.get_streaming_preset_name(2)) print(smp.recall_encoder_preset(3, 1)) print(smp.is_muted(2)) print(smp.mute_output(2)) print(smp.is_muted(2)) print(smp.unmute_output(2)) print(smp.is_muted(2)) if __name__ == '__main__': main()