844 lines
33 KiB
Python
844 lines
33 KiB
Python
"""
|
|
Recorder Adapter for SMP
|
|
"""
|
|
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 = "Recorder Adapter for SMP 351 and 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 SMP35x(TelnetAdapter, RecorderAdapter):
|
|
def __init__(self, address, password, auto_login=True, **kwargs):
|
|
RecorderAdapter.__init__(self, address, "", password)
|
|
TelnetAdapter.__init__(self, address)
|
|
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.password
|
|
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))
|
|
logger.debug("re-enter password")
|
|
self.tn.write(self.password + "\n\r")
|
|
# print(self.tn.assert_string_in_output("Login Administrator"))
|
|
self.tn = None
|
|
logger.error("Could definitely not login (as admin) with given password! {}".format(self.address))
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("input_num must be a value between 1 and 5!")
|
|
if channel_num not in range(1, 3):
|
|
raise LrcException("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 LrcException("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 LrcException("input_num must be a value between 1 and 5!")
|
|
if input_format not in range(1, 4):
|
|
raise LrcException("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 LrcException("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 LrcException("input_num must be a value between 1 and 5!")
|
|
if len(input_name) > 16:
|
|
raise LrcException("input_name must be no longer than 16 chars")
|
|
try:
|
|
input_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("channel_number must be a value between 1 and 2!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("channel_number must be a value between 1 and 2!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("preset_number must be a value between 1 and 16!")
|
|
if len(preset_name) > 16:
|
|
raise LrcException("preset_name must be no longer than 16 chars")
|
|
try:
|
|
preset_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("channel_number must be a value between 1 and 2!")
|
|
if preset_number not in range(1, 129):
|
|
raise LrcException("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 LrcException("channel_number must be a value between 1 and 2!")
|
|
if preset_number not in range(1, 129):
|
|
raise LrcException("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 LrcException("preset_number must be a value between 1 and 128!")
|
|
if len(preset_name) > 16:
|
|
raise LrcException("preset_name must be no longer than 16 chars")
|
|
try:
|
|
preset_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("output_number must be a value between 1 and 3!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("output_number must be a value between 1 and 3!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("preset_number must be a value between 1 and 16!")
|
|
if len(preset_name) > 16:
|
|
raise LrcException("preset_name must be no longer than 16 chars")
|
|
try:
|
|
preset_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("output_number must be a value between 1 and 3!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("output_number must be a value between 1 and 3!")
|
|
if preset_number not in range(1, 17):
|
|
raise LrcException("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 LrcException("preset_number must be a value between 1 and 16!")
|
|
if len(preset_name) > 16:
|
|
raise LrcException("preset_name must be no longer than 16 chars")
|
|
try:
|
|
preset_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("preset_number must be a value between 1 and 16!")
|
|
if len(preset_name) > 16:
|
|
raise LrcException("preset_name must be no longer than 16 chars")
|
|
try:
|
|
preset_name.encode('ascii')
|
|
except UnicodeEncodeError:
|
|
raise LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("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 LrcException("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
|
|
"""
|
|
|
|
@classmethod
|
|
def get_recorder_params(cls) -> dict:
|
|
return {'_requires_user': False,
|
|
'_requires_password': True}
|
|
|
|
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 LrcException("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 LrcException("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 LrcException("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 LrcException("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 = SMP35x(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()
|