def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
# Initialize class parent
ISniffer.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
computer = str(bench_params.get_param_value("Computer"))
# NOTE: import here to avoid circular dependency on
# EquipmentManager if imported at top level
from acs_test_scripts.Equipment.EquipmentManager import EquipmentManager
self._em = EquipmentManager()
self._computer = self._em.get_computer(computer)
self._ssh_process = None
self._ssh_queue = None
self._local_out = ""
self._sniff_ongoing = False
self._wifi_interface = bench_params.get_param_value("Interface", "")
if self._wifi_interface == "":
self._wifi_interface = self._computer.get_wifi_interface()
self._sniffer_tool_checked = False
self._sniffer_cmd = "NOT_YET_DEFINED"
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IHeadset.__init__(self)
self.__wired_headset = None
self.__headphone = None
self._bench_params = bench_params
# NOTE: import here to avoid circular dependency on
# EquipmentManager if imported at top level
from acs_test_scripts.Equipment.EquipmentManager import EquipmentManager
self._em = EquipmentManager()
self._io_card = self._em.get_io_card("IO_CARD")
if ((self._bench_params.has_parameter("wired_headset")) and
(self._bench_params.get_param_value("wired_headset") != "")):
self.__wired_headset = \
int(self._bench_params.get_param_value("wired_headset"))
if ((self._bench_params.has_parameter("headphone"))
and (self._bench_params.get_param_value("headphone") != "")):
self.__headphone = \
int(self._bench_params.get_param_value("headphone"))
if self._io_card is None:
self._logger.info("No IO card instance")
def __init__(self, name, model, eqt_params):
"""
Constructor
"""
# Initialize class parent
IComputer.__init__(self)
Iperf.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
self._os = None
# WiFi interface name
self._wifi_interface = None
self._usb_interface = None
self._tethering_interface = "RNDIS"
self._queue = None
self._event_cmd_ended = None
self._host = "localhost"
self._login = eqt_params.get_param_value("username", "root")
self._password = eqt_params.get_param_value("password", "")
self._key = eqt_params.get_param_value("ssh_key", "")
if self._key == "":
self._key = None
# Check ssh and scp full path name
self._ssh_bin = str(eqt_params.get_param_value("SshPath", ""))
self._scp_bin = str(eqt_params.get_param_value("ScpPath", ""))
self._ssh_bin = self.__join_exe_if_missing(self._ssh_bin, "ssh")
self._scp_bin = self.__join_exe_if_missing(self._scp_bin, "scp")
self._ssh_checked = False
self._scp_checked = False
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IIOCard.__init__(self)
self.__bench_params = bench_params
self.__handle = None
self.__default_states = USBRly08.__DEFAULT_STATE_TABLE
self.__wiring_table = USBRly08.__DEFAULT_WIRING_TABLE
self.__usb_host_pc_connect_relay = None
self.__usb_host_pc_power_minus = None
self.__usb_host_pc_data_plus = None
self.__usb_host_pc_data_minus = None
self.__power_supply_relay = None
self.__ps_sense_shunt_relay = None
self.__switch_on_off_relay = None
self.__wall_charger_relay = None
self.__wireless_charger_relay = None
self.__rpc_server_port = None
self.__wall_charger = None
self.__selected_usb_device = USBRly08.USB_HOST_PC
self.__test_status_display_connect_relay = None
self.__provisioning_mode = None
self.__usb_otg_type_relay = None
self.__lamp_relay = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: BenchConfigParameters
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
self._bench_params = bench_params
self._visa = None
# configuration file:
# keep only the root node of the xml tree
self._root_node = None
self._loaded_conf = []
transport = self._bench_params.get_param_value("Transport", default_value="GPIB")
if transport == VisaInterface.GPIB_TRANSPORT:
kwargs = {"GPIBBoardId": self._bench_params.get_param_value("GPIBBoardId"),
"GPIBAddress": self._bench_params.get_param_value("GPIBAddress")}
elif transport == VisaInterface.TCPIP_TRANSPORT:
kwargs = {"TcpIpAddress": self._bench_params.get_param_value("TcpIpAddress"),
"TcpIpBoardId": self._bench_params.get_param_value("TcpIpBoardId", ""),
"TcpIpDeviceName": self._bench_params.get_param_value("TcpIpDeviceName", "INST0")
}
elif transport == VisaInterface.SERIAL_TRANSPORT:
kwargs = {"ComPort": self._bench_params.get_param_value("ComPort")}
self.create_visa_interface(transport, kwargs)
def __init__(self, name, model, params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type params: dict
:param params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, params)
# Instantiate Pat library (by default NOT stubbed mode)
# - True = STUB mode (NiDAQ DLL is not loaded)
# - False or no argument = REAL mode (NiDAQ DLL is loaded)
# Configure Pat tool
if model == "STUB":
self.__instance = PowerMeasurements(True)
else:
self.__instance = PowerMeasurements(False)
self._plot = None
self._all_plots = {}
self._all_indicators = {}
self.detect_percent = 0.5
self.fact_min = 1 - self.detect_percent
self.fact_max = 1 + self.detect_percent
self.__pat_file = None
self.__rails_conf = None
def __init__(self, name, model, eqt_params, bench_params):
"""
This is the __init__ method of our class, default for all equipments
"""
if bench_params.has_parameter(STM32F4xx.STM_USB_ADDRESS):
self.stm_path = bench_params.get_param_value(
STM32F4xx.STM_USB_ADDRESS)
EquipmentBase.__init__(self, name, model, eqt_params)
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
# Initialize class parent
IConfigurableAP.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
self.__bench_params = bench_params
self.__handle = None
self._set_handle(None)
self._standard = None
self._profile = '1'
self._radio_status = "undef"
def __init__(self, name, model, eqt_params, bench_params):
if bench_params.has_parameter(SerialCom.BAUD_RATE):
self.baudRate = bench_params.get_param_value(SerialCom.BAUD_RATE)
else:
self.baudRate = 9600
if bench_params.has_parameter(SerialCom.COM_PORT):
self.port1 = bench_params.get_param_value(SerialCom.COM_PORT)
else:
self.port1 = SerialCom.DEFAULT_COM_PORT
EquipmentBase.__init__(self, name, model, eqt_params)
self.line = ""
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment catalog parameters
:type bench_params: dict
:param bench_params: the dictionary containing bench parameters of the equipment
"""
IGPSNetSim.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
self.__bench_params = bench_params
self.__handle = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
# Initialize class parent
EquipmentBase.__init__(self, name, model, eqt_params)
DllLoader.__init__(self, name, model, eqt_params)
self._serial_number = str(bench_params.get_param_value("SerialNumber"))
self._model_name = str(bench_params.get_param_value("EqtModel"))
self._dll = None
self._device_id = None
self._max_attenuation = None
self._min_attenuation = None
self._test_mode = self.TEST_MODE
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IController.__init__(self)
self.__bench_params = bench_params
self.__handle = None
self._reply_timeout = 120
def __init__(self, name, model, eqt_params, bench_params, controller):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
ITemperatureChamber.__init__(self)
self.__bench_params = bench_params
self.__equipement_address = 1
self.__controller = controller
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
# Initialize class parent
IConfigurableAP.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
self._bench_params = bench_params
self.__handle = None
# Extract time to wait for configuration of the equipment
self._configuration_timer = float(
bench_params.get_param_value("ConfigurationWaitingTime"))
# Retrieve parameters from BenchConfig for connection
self._host = str(bench_params.get_param_value("IP"))
self._username = str(bench_params.get_param_value("username"))
self._password = str(bench_params.get_param_value("password"))
# Retrieve the parameter of the AP to control through the AP controller
self._ap_name = str(bench_params.get_param_value("APC_AccessPoint"))
self._ap_ip = str(bench_params.get_param_value("APC_IP"))
self._ap_user = str(bench_params.get_param_value("APC_UserName"))
self._ap_pass = str(bench_params.get_param_value("APC_Password"))
self._ap_serial_ip = str(
bench_params.get_param_value("APC_SerialPortIP"))
self._ap_hostname = str(bench_params.get_param_value("APC_HostName"))
self._ap_power_ip = str(
bench_params.get_param_value("APC_PowerSwitchIPAddress"))
self._ap_power_hostname = str(
bench_params.get_param_value("APC_PowerSwitchHostname"))
self._ap_power_username = str(
bench_params.get_param_value("APC_PowerSwitchUsername"))
self._ap_power_password = str(
bench_params.get_param_value("APC_PowerSwitchPassword"))
self._ap_power_port = str(
bench_params.get_param_value("APC_PowerSwitchPort"))
self._ap_power_port = self._ap_power_port.strip()
# We consider that the power switch is opened by default
self._ap_powered_on = False
self._radio_status = "undef"
self._channel = None
self._standard = None
self._crda = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
# Initialize class parent
ILogicAnalyzer.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
self._socket_client = None
self._socket_server = None
self._clientSW = None
self._serverSW = None
self._bench_params = bench_params
self._out_q = None
self.READ_TIMEOUT = 5
self._stdout_thread = None
self._avail_formatters = {}
self._cur_os = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
# Initialize attributes
self.__bench_params = bench_params
self.__handle = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IIOCard.__init__(self)
self.__bench_params = bench_params
# what is the wall charger for th dut
self.__wall_charger = None
# do we use ext ps to supply usb
self._usb_supply_path = "USB_SUPPLY"
# default battery taken from device catalog
self.__default_battery = None
# current battery
self.__current_battery = None
# current battery state
self.__current_battery_state = None
# Type of Digital Battery
self.__digital_battery_type = None
# default battid value taken from device catalog
self.__default_batt_id_value = None
# current battid
self.__current_batt_id_value = None
# default bptherm value taken from device catalog
self.__default_bptherm_value = None
# is external power supply plug ?
self.__ext_ps_plug = False
# Client/Server things
self.__func_wrapper = EMT350Wrapper()
self.__io_card_conf = {}
self.__automatic_serial_com_port_detection = None
self.__serial_com_port = None
self.__serial_baud_rate = None
self.__retry_nb = None
self.__server_ip = None
self.__server_port = None
self.__multi_exec_needed = None
self.__usb_host = self.SDP
def __init__(self, name, model, eqt_params, bench_params):
"""
This is the constructor and will initiate serial connection
Raises:
AcsConfigException: if no communication port parameter defined in benchconfig file
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IUSBKM.__init__(self)
self.__bench_params = bench_params
if (self.__bench_params.has_parameter(IUSBKM.COM_PORT_ID_PARAM) and
self.__bench_params.get_param_value(IUSBKM.COM_PORT_ID_PARAM) != ""):
self.__com_port = str(self.__bench_params.get_param_value(IUSBKM.COM_PORT_ID_PARAM))
else:
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"No %s parameter defined in your benchconfig for equipment %s"
% (self.COM_PORT_ID_PARAM,name))
self.__serial_device = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor that always returns the same instance of ArtifactManager
"""
EquipmentBase.__init__(self, name, model, eqt_params)
self.__http_config = dict(proxy='system',
creds='anonymous',
http_timeout=10)
self.__bench_params = bench_params
self.__cache_size = DEFAULT_MAX_CACHE
self.__artifact_root_uri = DEFAULT_ARTIFACT_URI
self.__cache_artifacts_path = DEFAULT_CACHE_ARTIFACTS_PATH
self.__cache_engine = None
self.__http_downloader = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
IP2pClient.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
computer = str(bench_params.get_param_value("Computer"))
# NOTE: import here to avoid circular dependency on
# EquipmentManager if imported at top level
from acs_test_scripts.Equipment.EquipmentManager import EquipmentManager
self._em = EquipmentManager()
self._computer = self._em.get_computer(computer)
self._lan_interface = ""
self._p2pclient_ongoing = False
# Get binary file path
self._wpa_cli_bin = posixpath.realpath(eqt_params[model]["Binary"])
self._logger = self.get_logger()
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
"""
IP2pSupplicant.__init__(self)
EquipmentBase.__init__(self, name, model, eqt_params)
computer = str(bench_params.get_param_value("Computer"))
# NOTE: import here to avoid circular dependency on
# EquipmentManager if imported at top level
from acs_test_scripts.Equipment.EquipmentManager import EquipmentManager
self._em = EquipmentManager()
self._computer = self._em.get_computer(computer)
self._p2psupplicant_ongoing = False
# Get binary and cofiguration file path
self._wpa_supplicant_bin = posixpath.realpath(
eqt_params[model]["Binary"])
self._wpa_p2p_conf = posixpath.realpath(
eqt_params[model]["Configuration"])
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IUSBHub.__init__(self)
self.__bench_params = bench_params
if (self.__bench_params.has_parameter(IUSBHub.PRODUCT_ID_PARAM) and
self.__bench_params.get_param_value(IUSBHub.PRODUCT_ID_PARAM) != ""):
self.__product_id = int(self.__bench_params.get_param_value(IUSBHub.PRODUCT_ID_PARAM), 16)
else:
self.__product_id = DEFAULT_PRODUCT_ID
if (self.__bench_params.has_parameter(IUSBHub.VENDOR_ID_PARAM) and
self.__bench_params.get_param_value(IUSBHub.VENDOR_ID_PARAM) != ""):
self.__vendor_id = int(self.__bench_params.get_param_value(IUSBHub.VENDOR_ID_PARAM), 16)
else:
self.__vendor_id = DEFAULT_VENDOR_ID
if (self.__bench_params.has_parameter(IUSBHub.USB_BUS_PARAM) and
self.__bench_params.get_param_value(IUSBHub.USB_BUS_PARAM) != ""):
self.__vendor_id = int(self.__bench_params.get_param_value(IUSBHub.USB_BUS_PARAM), 16)
else:
self.__bus_id = DEFAULT_BUS_ID
if ((self.__bench_params.has_parameter(IUSBHub.USB_HOST_DUT_PORT_PARAM)) and
(self.__bench_params.get_param_value(IUSBHub.USB_HOST_DUT_PORT_PARAM) != "")):
self.__usb_host_dut_port = int(self.__bench_params.get_param_value(IUSBHub.USB_HOST_DUT_PORT_PARAM))
else:
self.__usb_host_dut_port = 1
# USB context hold all data necessary to handles USB devices from usb1
self.__context_usb = None
# The handle retreived on USB device used from USB context at usb1 level
self.__usb_component = None
def __init__(self, name, model, eqt_params, bench_params, factory=None):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params, factory)
IBTHeadset.__init__(self)
# instantiate IOCard
iocard = str(bench_params.get_param_value("IOCard"))
self._em = self._factory.create_equipment_manager()
self._iocard = self._em.get_io_card(iocard)
self._bench_params = bench_params
self._power_scard = None
self._powerbutton = None
self._volupbutton = None
self._voldownbutton = None
self._callbutton = None
self._fwdbutton = None
self._rwdbutton = None
self._playpausebutton = None
self._powerontimer = None
self._powerofftimer = None
self._defaultshortkeypresstimer = None
self._defaultlongkeypresstimer = None
self._betweendoublekeypresstimer = None
self._pairingtimer = None
self._voicedialtimer = None
self._bdaddress = None
self._bt_power_status = None
self._defaultreconnectprofiletimer = None
def __init__(self, name, model, eqt_params, bench_params):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params)
IthermalCamera.__init__(self)
self.__bench_params = bench_params
self.__protocol = None
self.__camera_ip_address = self.__bench_params.get_param_value("IP")
self.__camera_port = self.__bench_params.get_param_value(
"TelnetPort", "")
self.__login = self.__bench_params.get_param_value("FtpLoggin", "ACS")
self.__password = self.__bench_params.get_param_value(
"FtpPwd", "anonymous")
# camera setup to perform if you call the auto setup
self.__setup_auto_focus = self.__bench_params.get_param_value(
"AutoFocus", False)
self.__setup_image_color = self.__bench_params.get_param_value(
"ImageColor", False)
self.__setup_nuc = self.__bench_params.get_param_value(
"NonUniformityCorrection", False)
# image object parameters
if self.__login != "" and self.__password == "":
msg = "no password set for ftp login , this may cause a crash when you will try to pull file (ftplib limitation)"
self.get_logger().warning(msg)
self.__ftp = None
self.__meas_box = ".image.sysimg.measureFuncs.mbox.1"
self.__object_params = ".image.sysimg.basicImgData.objectParams"
def __init__(self, name, model, eqt_params):
"""
Constructor
"""
# Initialize class parent
EquipmentBase.__init__(self, name, model, eqt_params)
# Check OS requirement
if platform.system() != self.WINDOWS:
msg = "Operating System not recognized [%s] " % self._os
self._logger.error(msg)
self._logger.error(
"RF matrix uses a windows COM DLL so use a windows computer to control it"
)
raise TestEquipmentException(
TestEquipmentException.FEATURE_NOT_AVAILABLE, msg)
self._serial_number = eqt_params.get_param_value("SN", "")
self._config = eqt_params.get_param_value("Config", "SIMO")
if self._config not in ("MIMO", "SIMO"):
msg = "RF matrix support only MIMO or SIMO configuration" % self._config
self._logger.error(msg)
raise TestEquipmentException(
TestEquipmentException.INVALID_PARAMETER, msg)
def __init__(self, name, model, eqt_params, bench_params, factory=None):
"""
Constructor
:type name: str
:param name: the bench configuration name of the equipment
:type model: str
:param model: the model of the equipment
:type eqt_params: dict
:param eqt_params: the dictionary containing equipment parameters
:type bench_params: dict
:param bench_params: the dictionary containing equipment bench parameters
"""
EquipmentBase.__init__(self, name, model, eqt_params, factory)
# instantiate IOCard
iocard = str(bench_params.get_param_value("IOCard"))
self._em = self._factory.create_equipment_manager()
self._iocard = self._em.get_io_card(iocard)
self._bench_params = bench_params
self._power_scard = None
self._bdaddress = None
self._name = None
def __init__(self, bench_name, eqt_model, eqt_dic, bench_dic):
EquipmentBase.__init__(self, bench_name, eqt_model, eqt_dic)
self._host = bench_dic.get_param_value("IP")
McRCDAT.__init__(self, self._host)
self.set_logger(self._logger)