CT-60: Implemented Scan,EndScan with new base classes. (5de54e49) · Commits · Gianluca Marotta / csp-lmc-old

csp-lmc-common/csp_lmc_common/CspSubarray.py

+154 −125

Original line number	Original line	Diff line number	Diff line
	@@ -125,18 +125,13 @@ class CspSubarray(SKASubarray):
	information purpose only.		information purpose only.
	:rtype: (ResultCode, str)		:rtype: (ResultCode, str)
	"""		"""
	super().do()		(result_code, message) = super().do()

	device = self.target		device = self.target
	device._build_state = '{}, {}, {}'.format(release.name, release.version, release.description)		device._build_state = '{}, {}, {}'.format(release.name, release.version, release.description)
	self.logger.info("Initial state is:{}".format(device.get_state()))		self.logger.info("Initial state is:{}".format(device.get_state()))
	device._version_id = release.version		device._version_id = release.version
	# connect to CSP.LMC TANGO DB		# connect to CSP.LMC TANGO DB
	#device.set_state(tango.DevState.INIT)
	#device._health_state = HealthState.UNKNOWN
	#device._admin_mode = AdminMode.ONLINE
	#device._obs_mode = ObsMode.IDLE
	#device._obs_state = ObsState.IDLE
	# _config_delay_expected: inherited from the SKAObsDevice base class		# _config_delay_expected: inherited from the SKAObsDevice base class
	# Note: the _config_delay_expected could be set equal the max among the sub-elements		# Note: the _config_delay_expected could be set equal the max among the sub-elements
	# sub-arrays expected times for the command		# sub-arrays expected times for the command
	@@ -326,7 +321,7 @@ class CspSubarray(SKASubarray):

	message = "CspSubarray Init command completed OK"		message = "CspSubarray Init command completed OK"
	self.logger.info(message)		self.logger.info(message)
	return (ResultCode.OK, message)		return (result_code, message)

	class OnCommand(SKASubarray.OnCommand):		class OnCommand(SKASubarray.OnCommand):
	def do(self):		def do(self):
	@@ -371,7 +366,7 @@ class CspSubarray(SKASubarray):
	# state of the subarray is READY than subarray is not re-configured.		# state of the subarray is READY than subarray is not re-configured.
	if (stored_configuration == received_configuration) and (target_device._obs_state == ObsState.READY):		if (stored_configuration == received_configuration) and (target_device._obs_state == ObsState.READY):
	self.logger.info("Subarray is going to use the same configuration")		self.logger.info("Subarray is going to use the same configuration")
	return		return (ResultCode.OK, msg)
	except Exception as e:		except Exception as e:
	self.logger.warning(str(e))		self.logger.warning(str(e))
	# go ahead and parse the received configuration		# go ahead and parse the received configuration
	@@ -384,6 +379,9 @@ class CspSubarray(SKASubarray):
	msg,		msg,
	"Configure",		"Configure",
	tango.ErrSeverity.ERR)		tango.ErrSeverity.ERR)
			target_device._reconfiguring = False
			if target_device.state_model._obs_state == ObsState.READY:
			target_device._reconfiguring = True
	# Forward the Configure command to the sub-elements		# Forward the Configure command to the sub-elements
	# components (subarrays, pst beams)		# components (subarrays, pst beams)
	for device in target_device._sc_subarray_assigned_fqdn:		for device in target_device._sc_subarray_assigned_fqdn:
	@@ -422,7 +420,8 @@ class CspSubarray(SKASubarray):

	try:		try:
	# read the timeout configured for the operation on the device		# read the timeout configured for the operation on the device
	target_device._sc_subarray_duration_expected[device]['configurescan'] = proxy.configureDelayExpected		target_device._sc_subarray_cmd_duration_expected[device]['configurescan'] = target_device._get_expected_delay(proxy, "configureDelayExpected")
			self.logger.info("config delay: {}".format(target_device._sc_subarray_cmd_duration_expected[device]['configurescan']))
	except AttributeError as attr_err:		except AttributeError as attr_err:
	self.logger.info("No attribute {} on device {}".format(str(attr_err), device))		self.logger.info("No attribute {} on device {}".format(str(attr_err), device))
	try:		try:
	@@ -538,6 +537,7 @@ class CspSubarray(SKASubarray):
	# Note: the second check, can be useful if the timeout event is not received		# Note: the second check, can be useful if the timeout event is not received
	# (for example for a temporary connection timeout)		# (for example for a temporary connection timeout)
	elapsed_time = time.time() - target_device._sc_subarray_cmd_starting_time[device]		elapsed_time = time.time() - target_device._sc_subarray_cmd_starting_time[device]
			self.logger.info("elapsed_time:{}".format(elapsed_time))

	if (elapsed_time > target_device._sc_subarray_cmd_duration_expected[device][cmd_name] or		if (elapsed_time > target_device._sc_subarray_cmd_duration_expected[device][cmd_name] or
	target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.TIMEOUT):		target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.TIMEOUT):
	@@ -548,7 +548,9 @@ class CspSubarray(SKASubarray):
	self.logger.info("elapsed_time:{} device {}".format(elapsed_time, device))		self.logger.info("elapsed_time:{} device {}".format(elapsed_time, device))
	# check if sub-element command ended throwing an exception: in this case the		# check if sub-element command ended throwing an exception: in this case the
	# 'cmd_ended_cb' callback is invoked.		# 'cmd_ended_cb' callback is invoked.
	if target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED:		if target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED or \
			target_device._sc_subarray_obs_state[device] == ObsState.FAULT:
			target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.FAILED
	# execution ended for this sub-element, skip to the next one		# execution ended for this sub-element, skip to the next one
	device_done[device] = True		device_done[device] = True
	# update the progress counter inside the loop taking into account the number of devices		# update the progress counter inside the loop taking into account the number of devices
	@@ -563,7 +565,6 @@ class CspSubarray(SKASubarray):
	if all(value == True for value in device_done.values()):		if all(value == True for value in device_done.values()):
	self.logger.info("All devices have been handled!")		self.logger.info("All devices have been handled!")
	break		break
	self.logger.info("6")
	# check for global timeout expiration		# check for global timeout expiration
	# may be this check is not necessary		# may be this check is not necessary
	if target_device._cmd_duration_expected[cmd_name] < (time.time() - command_start_time):		if target_device._cmd_duration_expected[cmd_name] < (time.time() - command_start_time):
	@@ -575,9 +576,9 @@ class CspSubarray(SKASubarray):
	time.sleep(0.1)		time.sleep(0.1)
	# end of the while loop		# end of the while loop
	# check for timeout/failure conditions on each sub-component		# check for timeout/failure conditions on each sub-component
	if any(target_device._sc_subarray_cmd_exec_state[device] == CmdExecState.TIMEOUT for device in device_list):		if any(target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.TIMEOUT for device in device_list):
	target_device._timeout_expired = True		target_device._timeout_expired = True
	if any(target_device._sc_subarray_cmd_exec_state[device] == CmdExecState.FAILED for device in device_list):		if any(target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED for device in device_list):
	target_device._failure_raised = True		target_device._failure_raised = True
	# reset sub-component execution flag		# reset sub-component execution flag
	target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.IDLE		target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.IDLE
	@@ -600,7 +601,8 @@ class CspSubarray(SKASubarray):
	target_device._cmd_duration_measured[cmd_name] = time.time() - command_start_time		target_device._cmd_duration_measured[cmd_name] = time.time() - command_start_time
	target_device._cmd_progress[cmd_name] = 100		target_device._cmd_progress[cmd_name] = 100
	target_device._last_executed_command = cmd_name		target_device._last_executed_command = cmd_name
	target_device.configure_cmd_obj.succeeded()		self.logger.info("Configure ends with success!!")
			return target_device.configure_cmd_obj.succeeded()
	else:		else:
	return target_device.configure_cmd_obj.failed()		return target_device.configure_cmd_obj.failed()

	@@ -640,41 +642,43 @@ class CspSubarray(SKASubarray):

	class ScanCommand(SKASubarray.ScanCommand):		class ScanCommand(SKASubarray.ScanCommand):
	def do(self, argin):		def do(self, argin):
			target_device = self.target
	device = self.target
	try:		try:
	device._scan_id = int(argin[0])		target_device._scan_id = int(argin[0])
	except (ValueError, Exception) as err:		except (ValueError, Exception) as err:
	msg = "Scan command invalid argument:{}".format(str(err))		msg = "Scan command invalid argument:{}".format(str(err))
	self.logging.error(msg)		self.logging.error(msg)
	return (ResultCode.FAILED, msg)		return (ResultCode.FAILED, msg)
	# invoke the constructor for the command thread		# invoke the constructor for the command thread
	self.logger.info("Received Scan command with id:{}".format(self._scan_id))		self.logger.info("Received Scan command with id:{}".format(target_device._scan_id))
	for device in device._sc_subarray_assigned_fqdn:		self.logger.info("sc_subarray_assigned_fqdn: {}".format(target_device._sc_subarray_assigned_fqdn))
			for device in target_device._sc_subarray_assigned_fqdn:
	try:		try:
	proxy = device._sc_subarray_proxies[device]		proxy = target_device._sc_subarray_proxies[device]
	if not device._sc_subarray_event_id[device]['scancmdprogress']:		if not target_device._sc_subarray_event_id[device]['scancmdprogress']:
	evt_id = proxy.subscribe_event("scanCmdProgress",		evt_id = proxy.subscribe_event("scanCmdProgress",
	tango.EventType.CHANGE_EVENT,		tango.EventType.CHANGE_EVENT,
	device._attributes_change_evt_cb,		target_device._attributes_change_evt_cb,
	stateless=False)		stateless=False)
	device._sc_subarray_event_id[device]['scancmdprogress'] = evt_id		target_device._sc_subarray_event_id[device]['scancmdprogress'] = evt_id
	except KeyError as key_err:		except KeyError as key_err:
	self.logger.warning("No key {} found".format(key_err))		self.logger.warning("No key {} found".format(key_err))
	except tango.DevFailed as tango_err:		except tango.DevFailed as tango_err:
	self.logger.info(tango_err.args[0].desc)		self.logger.info(tango_err.args[0].desc)
	try:		try:
	proxy.command_inout_asynch("Scan", argin[0], device._cmd_ended_cb)		self.logger.info("Forwarding scan")
			proxy.command_inout_asynch("Scan", argin[0], target_device._cmd_ended_cb)
			self.logger.info("after Forwarding scan")
	except tango.DevFailed as tango_err:		except tango.DevFailed as tango_err:
	self.logger.info(tango_err.args[0].desc)		self.logger.info(tango_err.args[0].desc)
	# TODO: add check on the failed device. If CBF		# TODO: add check on the failed device. If CBF
	# throw an exception.		# throw an exception.
	# invoke the constructor for the command thread		# invoke the constructor for the command thread
	device._command_thread['scan'] = threading.Thread(target=self.__monitor_scan_execution,		target_device._command_thread['scan'] = threading.Thread(target=self.__monitor_scan_execution,
	name="Thread-Scan",		name="Thread-Scan",
	args=(device._sc_subarray_assigned_fqdn,))		args=(target_device._sc_subarray_assigned_fqdn,))
	device._cmd_execution_state['scan'] = CmdExecState.RUNNING		target_device._cmd_execution_state['scan'] = CmdExecState.RUNNING
	device._command_thread['scan'].start()		target_device._command_thread['scan'].start()
	return (ResultCode.STARTED, "Scan command started")		return (ResultCode.STARTED, "Scan command started")

	def __monitor_scan_execution(self, device_list):		def __monitor_scan_execution(self, device_list):
	@@ -694,8 +698,8 @@ class CspSubarray(SKASubarray):
	device_done = defaultdict(lambda:False)		device_done = defaultdict(lambda:False)
	elapsed_time = 0		elapsed_time = 0
	starting_time = time.time()		starting_time = time.time()
	self._end_scan_event.clear()		target_device._end_scan_event.clear()
	# inside the end-less lop check the obsState of each sub-component		# inside the end-less loop check the obsState of each sub-component
	while True:		while True:
	# Note: CbfSubarray changes the obsState value after forwarding the command		# Note: CbfSubarray changes the obsState value after forwarding the command
	# (synchrnously) to FSP and VCC devices. This means that When the thread function enters,		# (synchrnously) to FSP and VCC devices. This means that When the thread function enters,
	@@ -707,13 +711,13 @@ class CspSubarray(SKASubarray):
	#if self._abort_command_event.is_set():		#if self._abort_command_event.is_set():
	# dev_successful_state = ObsState.IDLE		# dev_successful_state = ObsState.IDLE
	#if self._end_scan_event.is_set() or self._abort_command_event.is_set():		#if self._end_scan_event.is_set() or self._abort_command_event.is_set():
	if target_device._end_scan_event.is_set():
	for device in device_list:		for device in device_list:
	if device_done[device] == True:		if device_done[device] == True:
	continue		continue
	# if the sub-component execution flag is no more RUNNING, the command has		# if the sub-component execution flag is no more RUNNING, the command has
	# ended with or without success. Go to check next device state.		# ended with or without success. Go to check next device state.
	if target_device._sc_subarray_obs_state[device] == dev_successful_state:		if target_device._sc_subarray_obs_state[device] == dev_successful_state:
			if target_device._end_scan_event.is_set():
	self.logger.info("Command {} ended with success on device {}.".format(cmd_name,		self.logger.info("Command {} ended with success on device {}.".format(cmd_name,
	device))		device))
	# update the list and number of device that completed the task		# update the list and number of device that completed the task
	@@ -727,31 +731,39 @@ class CspSubarray(SKASubarray):
	device_done[device] = True		device_done[device] = True
	# check if sub-element command ended throwing an exception: in this case the		# check if sub-element command ended throwing an exception: in this case the
	# 'cmd_ended_cb' callback is invoked.		# 'cmd_ended_cb' callback is invoked.
	if target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED:		if target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED or\
			target_device._sc_subarray_obs_state[device] == ObsState.FAULT:
	# execution ended for this sub-element, skip to the next one		# execution ended for this sub-element, skip to the next one
			target_device._failure_raised = True
	device_done[device] = True		device_done[device] = True
			target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.IDLE
			# TODO: handle connection problems
			#if target_device._sc_subarray_state[device] == DevState.UNKNOWN:
			# self.logger.warning("Connection with device {} temporaly down".format(device))
	if any(device_done.values()) and all(value == True for value in device_done.values()):		if any(device_done.values()) and all(value == True for value in device_done.values()):
	self.logger.info("All devices have been handled!")		self.logger.info("All devices have been handled!")
	break		break
			self.logger.info("Going to sleep")
	time.sleep(0.2)		time.sleep(0.2)

	# end of the while loop		# end of the while loop
			target_device._cmd_execution_state[cmd_name] = CmdExecState.IDLE
	# check for timeout/failure conditions on each sub-component		# check for timeout/failure conditions on each sub-component
	if any(target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED for device in device_list):		if any(target_device._sc_subarray_cmd_exec_state[device][cmd_name] == CmdExecState.FAILED for device in device_list):
	target_device._failure_raised = True		target_device._failure_raised = True
	# reset sub-component execution flag		#return target_device.scan_cmd_obj.failed()
	target_device._sc_subarray_cmd_exec_state[device][cmd_name] = CmdExecState.IDLE		return
	target_device.scan_cmd_obj.failed()
	# update the progress counter at the end of the loop		# update the progress counter at the end of the loop
	if all(target_device._sc_subarray_obs_state[fqdn] == dev_successful_state for fqdn in device_list):		if all(target_device._sc_subarray_obs_state[fqdn] == dev_successful_state for fqdn in device_list):
	target_device._cmd_progress[cmd_name] = 100		target_device._cmd_progress[cmd_name] = 100
	elapsed_time = time.time() - starting_time		elapsed_time = time.time() - starting_time
	self.logger.info("Scan elapsed time:{}".format(elapsed_time))		self.logger.info("Scan elapsed time:{}".format(elapsed_time))
	target_device._cmd_execution_state[cmd_name] = CmdExecState.IDLE
	target_device._last_executed_command = cmd_name		target_device._last_executed_command = cmd_name
	target_device.scan_cmd_obj.succeeded()		#return target_device.scan_cmd_obj.succeeded()
			self.logger.info("Exiting from the scan thread!")
			return

	class EndScanCommand(SKASubarray.ScanCommand):		class EndScanCommand(SKASubarray.EndScanCommand):

	def do(self):		def do(self):
	target_device = self.target		target_device = self.target
	@@ -762,7 +774,10 @@ class CspSubarray(SKASubarray):
	for device in device_list:		for device in device_list:
	try:		try:
	proxy = target_device._sc_subarray_proxies[device]		proxy = target_device._sc_subarray_proxies[device]
	proxy.command_inout_asynch("EndScan", target_device._cmd_ended_cb)		#proxy.command_inout_asynch("EndScan", target_device._cmd_ended_cb)
			# Note: at the moment EndScan does not support STARTED code so can't start
			# asynchrnously
			proxy.command_inout("EndScan")
	except KeyError as key_err:		except KeyError as key_err:
	self.logger.warning("No key {} found".format(key_err))		self.logger.warning("No key {} found".format(key_err))
	except tango.DevFailed as tango_err:		except tango.DevFailed as tango_err:
	@@ -771,7 +786,7 @@ class CspSubarray(SKASubarray):
	# signal the failure raising the failure flag?		# signal the failure raising the failure flag?
	# set the threading endScan event		# set the threading endScan event
	target_device._end_scan_event.set()		target_device._end_scan_event.set()
	return (ResultCode.OK, "EndScan command executed OK")		return (ResultCode.STARTED, "EndScan command executed STARTED")

	'''		'''
	class AbortCommand(SKASubarray.AbortCommand):		class AbortCommand(SKASubarray.AbortCommand):
	@@ -1058,6 +1073,7 @@ class CspSubarray(SKASubarray):
	if evt.attr_value.name.lower() in ["state", "healthstate", "adminmode", "obsstate"]:		if evt.attr_value.name.lower() in ["state", "healthstate", "adminmode", "obsstate"]:
	self.logger.info("call to update_subarray_state()")		self.logger.info("call to update_subarray_state()")
	self.update_subarray_state()		self.update_subarray_state()
			self.logger.info("after update_subarray_state()")
	except tango.DevFailed as df:		except tango.DevFailed as df:
	self.logger.error(str(df.args[0].desc))		self.logger.error(str(df.args[0].desc))
	except Exception as except_occurred:		except Exception as except_occurred:
	@@ -1152,15 +1168,17 @@ class CspSubarray(SKASubarray):
	if evt:		if evt:
	if not evt.err:		if not evt.err:
	if evt.argout[0] == ResultCode.STARTED:		if evt.argout[0] == ResultCode.STARTED:
	self.logger.info("Device {} is processing the command {}".format(evt.device,		self.logger.info("Device {} is processing the command {}".format(evt.device.dev_name(),
	evt.cmd_name))		evt.cmd_name))
	if evt.argout[0] == ResultCode.OK:		if evt.argout[0] == ResultCode.OK:
	self.logger.info("Device {} successfully processed the command {}".format(evt.device,		self.logger.info("Device {} successfully processed the command {}".format(evt.device.dev_name(),
	evt.cmd_name))		evt.cmd_name))
	if evt.argout[0] == ResultCode.FAILED:		if evt.argout[0] == ResultCode.FAILED:
	self.logger.info("Failure in Device {} while processing the command {}".format(evt.device,		self.logger.info("Failure in Device {} while processing the command {}".format(evt.device.dev_name(),
	evt.cmd_name))		evt.cmd_name))
	self._sc_subarray_cmd_exec_state[evt.device.dev_name()][evt.cmd_name.lower()] = CmdExecState.FAILED		self._sc_subarray_cmd_exec_state[evt.device.dev_name()][evt.cmd_name.lower()] = CmdExecState.FAILED
			self.logger.info("sc_subarray_cmd_exec_state[{}][{}]:{}".format(evt.device.dev_name(), evt.cmd_name.lower(),
			self._sc_subarray_cmd_exec_state[evt.device.dev_name()][evt.cmd_name.lower()]))
	self._failure_message[evt.cmd_name.lower()] += evt.argout[1]		self._failure_message[evt.cmd_name.lower()] += evt.argout[1]
	else:		else:
	msg = "Error!!Command {} ended on device {}.\n".format(evt.cmd_name,		msg = "Error!!Command {} ended on device {}.\n".format(evt.cmd_name,
	@@ -1209,13 +1227,16 @@ class CspSubarray(SKASubarray):
	self.set_state(self._sc_subarray_state[self.CbfSubarray])		self.set_state(self._sc_subarray_state[self.CbfSubarray])
	if self.get_state() == DevState.OFF:		if self.get_state() == DevState.OFF:
	if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:		if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:
			self.logger.info("1")
	self.off_cmd_obj.succeeded()		self.off_cmd_obj.succeeded()
	if self.get_state() == DevState.ON:		if self.get_state() == DevState.ON:
	if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:		if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.EMPTY:
			self.logger.info("2")
	self.on_cmd_obj.succeeded()		self.on_cmd_obj.succeeded()
	if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.READY:		if self._sc_subarray_obs_state[self.CbfSubarray] == ObsState.READY:
	self.configure_cmd_obj.succeeded()		self.configure_cmd_obj.succeeded()
	self.logger.info("Csp subarray state: {} obsState: {}".format(self.get_state(), self.state_model.obs_state))		self.logger.info("3")
			#self.logger.info("Csp subarray state: {} obsState: {}".format(self.get_state(), self.state_model._obs_state))
	return True		return True

	def _update_subarray_health_state(self):		def _update_subarray_health_state(self):
	@@ -1297,6 +1318,14 @@ class CspSubarray(SKASubarray):
	"Subarray obsState:{}".format( self._obs_state))		"Subarray obsState:{}".format( self._obs_state))
	self.logger.info("Subarray ObsState:{}".format( self._obs_state))		self.logger.info("Subarray ObsState:{}".format( self._obs_state))
	'''		'''
			def _open_connection(self, fqdn):
			device_proxy = DeviceProxy(fqdn)
			return device_proxy

			def _get_expected_delay(self, attr_name, proxy):
			attr_value = proxy.read_attribute(attr_name)
			return attr_value.value()


	def connect_to_subarray_subcomponent(self, fqdn):		def connect_to_subarray_subcomponent(self, fqdn):
	"""		"""
	@@ -1314,18 +1343,18 @@ class CspSubarray(SKASubarray):
	return		return
	# read the sub-componet adminMode (memorized) attribute from		# read the sub-componet adminMode (memorized) attribute from
	# the CSP.LMC TANGO DB.		# the CSP.LMC TANGO DB.
	#attribute_properties = self._csp_tango_db.get_device_attribute_property(fqdn,		attribute_properties = self._csp_tango_db.get_device_attribute_property(fqdn,
	# {'adminMode': ['__value']})		{'adminMode': ['__value']})
	#self.logger.debug("fqdn: {} attribute_properties: {}".format(fqdn, attribute_properties))		self.logger.debug("fqdn: {} attribute_properties: {}".format(fqdn, attribute_properties))
	#try:		try:
	# admin_mode_memorized = attribute_properties['adminMode']['__value']		admin_mode_memorized = attribute_properties['adminMode']['__value']
	# self._sc_subarray_admin_mode[fqdn] = int(admin_mode_memorized[0])		self._sc_subarray_admin_mode[fqdn] = int(admin_mode_memorized[0])
	#except KeyError as key_error:		except KeyError as key_error:
	# self.logger.warning("No key {} found".format(str(key_error)))		self.logger.warning("No key {} found".format(str(key_error)))
	try:		try:
	log_msg = "Trying connection to " + str(fqdn) + " device"		log_msg = "Trying connection to " + str(fqdn) + " device"
	self.logger.info(log_msg)		self.logger.info(log_msg)
	device_proxy = DeviceProxy(fqdn)		device_proxy = self._open_connection(fqdn)
	self.logger.info("fqdn: {} device_proxy: {}".format(fqdn, device_proxy))		self.logger.info("fqdn: {} device_proxy: {}".format(fqdn, device_proxy))
	# Note: The DeviceProxy is initialized even if the sub-component		# Note: The DeviceProxy is initialized even if the sub-component
	# device is not running (but defined into the TANGO DB! If not defined in the		# device is not running (but defined into the TANGO DB! If not defined in the
	@@ -1364,11 +1393,11 @@ class CspSubarray(SKASubarray):
	stateless=True)		stateless=True)
	self._sc_subarray_event_id[fqdn]['obsState'] = ev_id		self._sc_subarray_event_id[fqdn]['obsState'] = ev_id

	ev_id = device_proxy.subscribe_event("obsMode",		#ev_id = device_proxy.subscribe_event("obsMode",
	EventType.CHANGE_EVENT,		# EventType.CHANGE_EVENT,
	self._sc_scm_change_event_cb,		# self._sc_scm_change_event_cb,
	stateless=True)		# stateless=True)
	self._sc_subarray_event_id[fqdn]['obsMode'] = ev_id		#self._sc_subarray_event_id[fqdn]['obsMode'] = ev_id

	except KeyError as key_err:		except KeyError as key_err:
	log_msg = ("No key {} found".format(str(key_err)))		log_msg = ("No key {} found".format(str(key_err)))

csp-lmc-mid/csp_lmc_mid/MidCspSubarrayBase.py

+117 −95

File changed.

Preview size limit exceeded, changes collapsed.

csp-lmc-mid/csp_lmc_mid/receptors.py

0 → 100644

+126 −0

File added.

Preview size limit exceeded, changes collapsed.

csp-lmc-mid/tests/unit/midcspsubarray_unit_test.py

0 → 100644

+699 −0

File added.

Preview size limit exceeded, changes collapsed.