diff --git a/recorder_adapters/extron_smp.py b/recorder_adapters/extron_smp.py index 50b253f..a407e6c 100644 --- a/recorder_adapters/extron_smp.py +++ b/recorder_adapters/extron_smp.py @@ -20,7 +20,7 @@ class SMP(TelnetAdapter): def login(self): self.tn = telnetlib.Telnet(HOST) self.tn.read_until("\r\nPassword:") - #password = getpass.getpass() + # password = getpass.getpass() password = self.admin_pw self.tn.write(password + "\n\r") @@ -113,13 +113,11 @@ class SMP(TelnetAdapter): 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): + def set_verbose_mode(self, mode: int): """ Mode: 0=clear/none (default for telnet connections @@ -138,7 +136,6 @@ class SMP(TelnetAdapter): self.tn.write(self.esc_char + "CV\n") return TelnetAdapter.get_response_str(self.tn.read_until_non_empty_line()) - def save_configuration(self): pass @@ -256,15 +253,15 @@ class SMP(TelnetAdapter): :param channel_num: :return: """ - if input_num not in range(1,6): + 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): + 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): + 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()) @@ -279,33 +276,33 @@ class SMP(TelnetAdapter): :param input_format: :return: """ - if input_num not in range(1,6): + 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): + 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): + 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): + 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 not longer than 16 chars") + raise Exception("input_name must be no longer than 16 chars") try: input_name.encode('ascii') - except UnicodeDecodeError: + 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): + 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()) @@ -347,7 +344,7 @@ class SMP(TelnetAdapter): :param extension_time: must be an int from 0 to 99 :return: """ - if extension_time not in range(0,100): + 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()) @@ -381,7 +378,354 @@ class SMP(TelnetAdapter): """ def recall_user_preset(self, channel_number, preset_number): - pass # TODO + 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, preset_number): + 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, preset_name): + 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): + 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): + 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, preset_number): + 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, preset_number): + 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, preset_name): + 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): + 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): + 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, preset_number): + """ + 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, preset_number): + """ + 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, preset_name): + 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): + 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): + 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, preset_number): + """ + 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, preset_number): + """ + 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, preset_name): + 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): + 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): + 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): + 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, include_input_selections=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, preset_name): + 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): + 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): + 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): + """ + 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): + """ + 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): + """ + 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): + """ + 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): + 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): + 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): + 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()) smp = SMP(HOST, PW) @@ -398,7 +742,6 @@ 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()) @@ -410,3 +753,16 @@ 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))