def init_device(self):
"""
Method that initializes the tango device after startup.
:return: None
"""
Device.init_device(self)
# PROTECTED REGION ID(SKABaseDevice.init_device) ENABLED START #
# Initialize attribute values.
self._build_state = '{}, {}, {}'.format(release.name, release.version,
release.description)
self._version_id = release.version
self._central_logging_level = int(tango.LogLevel.LOG_OFF)
self._element_logging_level = int(tango.LogLevel.LOG_OFF)
self._storage_logging_level = int(tango.LogLevel.LOG_OFF)
self._health_state = 0
self._admin_mode = 0
self._control_mode = 0
self._simulation_mode = False
self._test_mode = ""
# create TANGO Groups objects dict, according to property
self.debug_stream("Groups definitions: {}".format(
self.GroupDefinitions))
try:
self.groups = get_groups_from_json(self.GroupDefinitions)
self.info_stream("Groups loaded: {}".format(
sorted(self.groups.keys())))
except GroupDefinitionsError:
self.info_stream("No Groups loaded for device: {}".format(
self.get_name()))
def init_device(self):
Device.init_device(self)
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
try:
self._nanoBpmProxy = tango.get_device_proxy(
self.NanoBPM,
green_mode=GreenMode.Gevent,
wait=True,
timeout=True)
if self.XController is not None:
self._xcontrolProxy = tango.DeviceProxy(self.XController)
if self.YController is not None:
self._ycontrolProxy = tango.DeviceProxy(self.YController)
self._event = gevent.event.Event()
self._servoId = None
self._xcoord = 0
self._ycoord = 0
self._xmovePerPixel = 1.0
self._ymovePerPixel = 1.0
self._xcentre = 640
self._ycentre = 512
self._minimumXMove = 1.0
self._minimumYMove = 1.0
self._maximumXMove = 100.0
self._maximumYMove = 100.0
if self._nanoBpmProxy is not None:
self._centreId = self._nanoBpmProxy.subscribe_event(
"Centre", tango.EventType.CHANGE_EVENT, self)
self.set_state(tango.DevState.ON)
except:
self.set_state(tango.DevState.FAULT)
def init_device(self):
Device.init_device(self)
# ToDo: implement somthing that uses channels to distingush between 261 and 262
if self.Type == 'TPG261':
self.controller = TPG261(port=self.Port)
self.connection = self.controller.serial
if self.connection.isOpen():
self.set_state(DevState.ON)
self.info_stream('TPG261 initialised on port %s.' %
self.connection.port)
elif self.Type == 'TPG262':
self.controller = TPG262(port=self.Port)
self.connection = self.controller.serial
if self.connection.isOpen():
self.set_state(DevState.ON)
self.info_stream('TPG262 initialised on port %s.' %
self.connection.port)
else:
pass
self._minute_array = np.empty(60)
self._minute_array[:] = np.NaN
self._hour_array = np.empty(60)
self._hour_array[:] = np.NaN
self._day_array = np.empty(24)
self._day_array[:] = np.NaN
self._month_array = np.empty(30)
self._month_array[:] = np.NaN
self._time = np.ones(4) * time() # minute, hour, day, month
def init_device(self):
"""Device constructor."""
Device.init_device(self)
self._set_master_state('init')
# Add anything here that has to be done before the device is set to
# its ON state.
self._set_master_state('on')
def init_device(self):
Device.init_device(self)
kwargs = {
'command_url': self.CommandUrl,
'control_url': self.ControlUrl,
}
self._nanoBpm = nanoBpm(self.Name, kwargs)
self._AcqMode2String = {
self.CONTINUOUS: 'continuous',
self.STREAMING: 'stream'
}
self.imageDepth2String = {
self.BPP8: "bpp8",
self.BPP16: "bpp16",
self.BPP32: "bpp32"
}
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
self._imageDepth = self.BPP8
self._imageData = None
self._lock = lock.Semaphore()
self._acqMode = self.STREAMING
self._CoG = None
self._xprofile = None
self._yprofile = None
self._xfit = None
self._yfit = None
# set up change events for Tango clients
self.set_change_event("Centre", True, False)
self.set_change_event("Xprofile", True, False)
self.set_change_event("Yprofile", True, False)
self.set_change_event("Xfit", True, False)
self.set_change_event("Yfit", True, False)
self.set_change_event("ReadImage8", True, False)
self.set_change_event("ReadImage16", True, False)
self.set_change_event("ReadImage32", True, False)
self._nanoBpm.subscribe(self.bpmCallback)
attr = self.get_device_attr().get_attr_by_name("acqMode")
attr.set_write_value(self._AcqMode2String[self._acqMode])
attr = self.get_device_attr().get_attr_by_name("imageDepth")
attr.set_write_value(self.imageDepth2String[self._imageDepth])
if self._nanoBpm is not None:
attr = self.get_device_attr().get_attr_by_name("gain")
attr.set_write_value(self._nanoBpm.GAIN)
attr = self.get_device_attr().get_attr_by_name("offset")
attr.set_write_value(self._nanoBpm.OFFSET)
attr = self.get_device_attr().get_attr_by_name("horizMinAmp")
attr.set_write_value(self._nanoBpm.H_MINAMP)
attr = self.get_device_attr().get_attr_by_name("vertMinAmp")
attr.set_write_value(self._nanoBpm.V_MINAMP)
attr = self.get_device_attr().get_attr_by_name("vertMinRSQ")
attr.set_write_value(self._nanoBpm.V_MINRSQ)
attr = self.get_device_attr().get_attr_by_name("horizMinRSQ")
attr.set_write_value(self._nanoBpm.H_MINRSQ)
attr = self.get_device_attr().get_attr_by_name("maxIter")
attr.set_write_value(self._nanoBpm.MAXITER)
self.set_state(tango.DevState.ON)
def init_device(self):
Device.init_device(self)
try:
self.pilc = DeviceProxy(self.PiLCFQDN)
self.info_stream('Connected to PiLC: {:s}'.format(self.PiLCFQDN))
except:
self.error_stream('Could not connect to PiLC: {:s}'.format(
self.PiLCFQDN))
return
self.set_state(DevState.OFF)
self.set_state(DevState.ON)
self.db = Database()
try:
attr = self.db.get_device_attribute_property(
self.get_name(), ["exposure"])
self._exposure = int(attr["exposure"]["__value"][0])
except Exception:
self._exposure = -1
try:
attr = self.db.get_device_attribute_property(
self.get_name(), ["mode"])
self._mode = int(attr["mode"]["__value"][0])
except Exception:
self._mode = 0
def init_device(self):
with _lock:
self.error_count = 0
self.values = [float('NaN')] * 6
self.time = time.time() - 100.0
self.set_state(DevState.INIT)
Device.init_device(self)
self.last_level = logging.INFO
# get port and address from property
port = self.get_device_property('port', 'COM1')
addr = self.get_device_property('addr', 6)
# create TDKLambda device
self.tdk = TDKLambda(port, addr)
# self.tdk.init()
# check if device OK
if self.tdk.initialized():
# add device to list
TDKLambda_Server.devices.append(self)
# set state to running
self.set_state(DevState.RUNNING)
msg = '%s:%d TDKLambda %s created successfully' % (
self.tdk.port, self.tdk.addr, self.tdk.id)
logger.info(msg)
# self.info_stream(msg)
else:
msg = '%s:%d TDKLambda device created with errors' % (
self.tdk.port, self.tdk.addr)
logger.error(msg)
# self.error_stream(msg)
self.set_state(DevState.FAULT)
def init_device(self):
Device.init_device(self)
self.info_stream('Connecting to serial port {:s} ...'.format(self.Port))
try:
self.serial = serial.Serial(
port = self.Port,
baudrate = 921600,
bytesize = 8,
stopbits = 1,
parity = 'N',
xonxoff = True,
timeout = 0.050
)
if self.serial.isOpen():
self.serial.close()
self.serial.open()
self.info_stream('Connection established:\n{:s}\n{:s}'.format(
self.query('ID?'),
self.query('VE?')
))
self.set_state(DevState.ON)
except:
self.error_stream('Cannot connect!')
self.set_state(DevState.OFF)
def init_device(self):
Device.init_device(self)
self.rootBlobName = 'theBlob'
self.__blob = self.rootBlobName, dict(x=0.3,
y=10.22,
width=105.1,
height=206.6)
def __init__(self, *args, **kwargs):
self._musst = None
Device.__init__(self, *args, **kwargs)
self._musst2tangostate = {
musst_ctrl.NOPROG_STATE : tango.DevState.OFF,
musst_ctrl.BADPROG_STATE : tango.DevState.UNKNOWN,
musst_ctrl.IDLE_STATE : tango.DevState.ON,
musst_ctrl.RUN_STATE : tango.DevState.RUNNING,
musst_ctrl.BREAK_STATE : tango.DevState.STANDBY,
musst_ctrl.STOP_STATE : tango.DevState.STANDBY,
musst_ctrl.ERROR_STATE : tango.DevState.FAULT
}
self._musststate2string = {
musst_ctrl.NOPROG_STATE : "No Program loaded in Musst",
musst_ctrl.BADPROG_STATE : "Musst has a bad program loaded",
musst_ctrl.IDLE_STATE : "Musst program loaded in idle state",
musst_ctrl.RUN_STATE : "Musst is running program",
musst_ctrl.BREAK_STATE : "Musst progam at breakpoint",
musst_ctrl.STOP_STATE : "Musst program stopped",
musst_ctrl.ERROR_STATE : "Musst has an error condition"
}
self.__frequency_conversion = {
musst_ctrl.F_1KHZ : "1KHZ",
musst_ctrl.F_10KHZ : "10KHZ",
musst_ctrl.F_100KHZ : "100KHZ",
musst_ctrl.F_1MHZ : "1MHZ",
musst_ctrl.F_10MHZ : "10MHZ",
musst_ctrl.F_50MHZ : "50MHZ"
}
def init_device(self):
self.info_stream('Trying to establish connection')
try:
Device.init_device(self)
self.dev = ni.get_adapter()
self.set_state(DevState.ON)
self.dev.set_io_mode(0b00000000, 0b01111111,
0b00000000) #only ports 1.0-1.7 are writeable
self.__ports = {3: False, 4: False, 5: False, 6: False, 7: False}
self.__active = '0b00000000'
self.dev.write_port(1, int(self.__active, 2))
self.info_stream('Connection established.')
self.__gatetime = 1
self.__act_port = 3
self.__freq = 1
self.__npulses = 1
self.__busy = False
except:
if not self.dev:
self.error_stream('Connection could not be established')
self.set_state(DevState.FAULT)
else:
#Connection already running (info_stream gets called in case
#the init method is called more than once)
self.info_stream(
'Connection has already been established in a prior run.')
def init_device(self):
Device.init_device(self)
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
try:
self._nanoBpmProxy = tango.get_device_proxy(self.NanoBPM, green_mode=GreenMode.Gevent, wait=True, timeout=True)
if self.XController is not None:
self._xcontrolProxy = tango.DeviceProxy(self.XController)
if self.YController is not None:
self._ycontrolProxy = tango.DeviceProxy(self.YController)
self._event = gevent.event.Event()
self._servoId = None
self._xcoord = 0
self._ycoord = 0
self._xmovePerPixel = 1.0
self._ymovePerPixel = 1.0
self._xcentre = 640;
self._ycentre = 512;
self._minimumXMove = 1.0
self._minimumYMove = 1.0
self._maximumXMove = 100.0
self._maximumYMove = 100.0
if self._nanoBpmProxy is not None:
self._centreId = self._nanoBpmProxy.subscribe_event("Centre", tango.EventType.CHANGE_EVENT, self)
self.set_state(tango.DevState.ON)
except:
self.set_state(tango.DevState.FAULT)
def init_device(self):
Device.init_device(self)
kwargs = {
'command_url': self.CommandUrl,
'control_url': self.ControlUrl,
}
self._nanoBpm = nanoBpm(self.Name, kwargs)
self._AcqMode2String = {
self.CONTINUOUS : 'continuous',
self.STREAMING : 'stream'
}
self.imageDepth2String = {
self.BPP8 : "bpp8",
self.BPP16 : "bpp16",
self.BPP32 : "bpp32"
}
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
self._imageDepth = self.BPP8
self._imageData = None
self._lock = lock.Semaphore()
self._acqMode = self.STREAMING
self._CoG = None
self._xprofile = None
self._yprofile = None
self._xfit = None
self._yfit = None
# set up change events for Tango clients
self.set_change_event("Centre", True, False)
self.set_change_event("Xprofile", True, False)
self.set_change_event("Yprofile", True, False)
self.set_change_event("Xfit", True, False)
self.set_change_event("Yfit", True, False)
self.set_change_event("ReadImage8", True, False)
self.set_change_event("ReadImage16", True, False)
self.set_change_event("ReadImage32", True, False)
self._nanoBpm.subscribe(self.bpmCallback)
attr = self.get_device_attr().get_attr_by_name("acqMode")
attr.set_write_value(self._AcqMode2String[self._acqMode])
attr = self.get_device_attr().get_attr_by_name("imageDepth")
attr.set_write_value(self.imageDepth2String[self._imageDepth])
if self._nanoBpm is not None:
attr = self.get_device_attr().get_attr_by_name("gain")
attr.set_write_value(self._nanoBpm.GAIN)
attr = self.get_device_attr().get_attr_by_name("offset")
attr.set_write_value(self._nanoBpm.OFFSET)
attr = self.get_device_attr().get_attr_by_name("horizMinAmp")
attr.set_write_value(self._nanoBpm.H_MINAMP)
attr = self.get_device_attr().get_attr_by_name("vertMinAmp")
attr.set_write_value(self._nanoBpm.V_MINAMP)
attr = self.get_device_attr().get_attr_by_name("vertMinRSQ")
attr.set_write_value(self._nanoBpm.V_MINRSQ)
attr = self.get_device_attr().get_attr_by_name("horizMinRSQ")
attr.set_write_value(self._nanoBpm.H_MINRSQ)
attr = self.get_device_attr().get_attr_by_name("maxIter")
attr.set_write_value(self._nanoBpm.MAXITER)
self.set_state(tango.DevState.ON)
def init_device(self):
"""Initialise the device."""
Device.init_device(self)
# PROTECTED REGION ID(SDPMaster.init_device) ENABLED START #
# Initialise Attributes
self._operating_state = 0
self.set_state(DevState.ON)
self._health_state = HealthState.OK
def init_device(self):
"""Initialises the attributes and properties of the Counter."""
Device.init_device(self)
# PROTECTED REGION ID(Counter.init_device) ENABLED START #
self._value = 0
self._fire_event_at = 0
self.set_change_event("value", True, False)
self.set_change_event("polled_value", True, True)
def init_device(self):
# tango equivalent of pythons __init__. so we have to declare instance variables here...
self.move_step_size_value_fs = 1
self.stage = StandaXimcClient(STANDA_HOST, STANDA_PORT, debug=DEBUG)
sys.stdout = StoreStdOut()
Device.init_device(self)
self.set_state(DevState.OFF)
self.connect()
def init_device(self) :
Device.init_device(self)
self.set_state(tango.DevState.FAULT)
self.get_device_properties(self.get_device_class())
config = static.get_config()
self.__multiplexer = config.get(self.multiplexer_name)
self.__multiplexer.load_program()
self.set_state(tango.DevState.ON)
def init_device(self):
Device.init_device(self)
self.set_state(tango.DevState.FAULT)
self.get_device_properties(self.get_device_class())
config = static.get_config()
self.__multiplexer = config.get(self.multiplexer_name)
self.__multiplexer.load_program()
self.set_state(tango.DevState.ON)
def init_device(self):
"""Device constructor."""
Device.init_device(self)
# Add anything here that has to be done before the device is set to
# its ON state.
self._set_master_state('on')
self._devProxy = DeviceProxy(self.get_name())
def init_device(self):
"""Device constructor."""
start_time = time.time()
Device.init_device(self)
self._pb_id = ''
LOG.debug('Init PB device %s, time taken %.6f s (total: %.2f s)',
self.get_name(), (time.time() - start_time),
(time.time() - self._start_time))
self.set_state(DevState.STANDBY)
def init_device(self):
"""Device constructor."""
Device.init_device(self)
# Add anything here that has to be done before the device is set to
# its ON state.
self._set_master_state('on')
self._devProxy = DeviceProxy(self.get_name())
def init_device(self):
Device.init_device(self)
kwargs = dict(url=self.url,
pad=self.pad,
sad=self.sad,
timeout=self.timeout,
tmo=self.tmo)
self.gpib = _Gpib(**kwargs)
self.gpib.open()
def init_device(self):
"""Device constructor."""
start_time = time.time()
Device.init_device(self)
self._pb_id = ''
LOG.debug('init PB device %s, time taken %.6f s (total: %.2f s)',
self.get_name(), (time.time() - start_time),
(time.time() - self._start_time))
self.set_state(DevState.STANDBY)
def init_device(self):
Device.init_device(self)
kwargs = {
'gpib_url': self.url,
'gpib_pad': self.pad,
'gpib_timeout': self.timeout,
'gpib_eos': self.eos
}
self._keithley = keithley(self.name, kwargs)
self.set_state(tango.DevState.ON)
def init_device(self):
Device.init_device(self)
kwargs = {
'gpib_url': self.url,
'gpib_pad': self.pad,
'gpib_timeout': self.timeout,
'gpib_eos' : self.eos
}
self._musst = musst_ctrl(self.name, kwargs)
self.create_dynamic_attributes()
def init_device(self):
Device.init_device(self)
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.connect((self.host, self.port))
self.s.setblocking(True)
self.lock = Lock()
self.set_state(DevState.ON)
energy = self.read_attr('photonenergy')[0]
self._setpoint_E = [energy, energy]
self._setpoint_helicity = self.read_attr('helicity')[0]
def init_device(self):
self.debug_stream("Preparing device")
Device.init_device(self)
try:
self.image_proxy = AttributeProxy(self.ImageProxy)
self.debug_stream('Init was done')
except:
self.error_stream('Could not contact camera :( ')
self.set_state(DevState.OFF)
self.set_state(DevState.ON)
def init_device(self):
Device.init_device(self)
self.info_stream('Connection established') # prints this line while -
# in logging mode "info" or lower
self.set_state(DevState.ON)
# here you could initiate first contact to the hardware (driver)
self.__temp = 0 # declaring values for the attributes if needed
self.__humid = 0
def init_device(self):
Device.init_device(self)
self.info_stream('In Python init_device method')
self.serial = serial.serial_for_url(self.port)
self.status_packet = None
self.status_thread = threading.Thread(group=None,
target=self.update_status_packet)
self.status_thread_stop = threading.Event()
self.status_thread.start()
self.set_state(DevState.ON)
def init_device(self):
Device.init_device(self)
self.info_stream('Connecting to Cyberstart model: {} '
'port: {} addr: {}'.format(self.model,
self.port,
self.addr))
model = Models.from_str(self.model)
if self.library_debug:
logging.basicConfig(level=logging.DEBUG)
try:
self.cyber = CyberstarController(self.port, model, self.addr)
except Exception as e:
self.set_state(DevState.FAULT)
self.set_status('Can not connect to HW: {}'.format(e))
self.set_state(DevState.ON)
self.set_status('Device ready')
# Attribute configuration: Name, unit, type, R/W
attrs_conf = [
['PeakingTime', 'ns', DevLong, AttrWriteType.READ_WRITE],
['Gain', '%', DevDouble, AttrWriteType.READ_WRITE],
['SCALow', 'V', DevDouble, AttrWriteType.READ_WRITE],
['SCAHigh', 'V', DevDouble, AttrWriteType.READ_WRITE],
]
if model == Models.X1000:
attrs_conf += [
['Voltage', 'V', DevDouble, AttrWriteType.READ_WRITE],
['Delay', 's', DevDouble, AttrWriteType.READ_WRITE],
['SecurityEnabled', '', DevBoolean, AttrWriteType.READ_WRITE]
]
elif model == Models.X2000:
attrs_conf += [
['Saturation', '', DevBoolean, AttrWriteType.READ]
]
for i in range(1, self.cyber.channels+1):
for attr_conf in attrs_conf:
name, unit, dtype, r_w = attr_conf
attr_name = 'Chn{}{}'.format(i, name)
attr_prop = UserDefaultAttrProp()
if unit != '':
attr_prop.set_display_unit(unit)
attr_prop.set_standard_unit(unit)
attr_prop.set_unit(unit)
attr = Attr(attr_name, dtype, r_w)
attr.set_default_properties(attr_prop)
r_meth = self.read_attribute
w_meth = None
if r_w == AttrWriteType.READ_WRITE:
w_meth = self.write_attribute
self.add_attribute(attr, r_meth, w_meth)
def init_device(self):
self.info_stream('Trying to connect device to server.')
try:
Device.init_device(self)
self.am2315 = am_driver.AM2315()
self.set_state(DevState.ON)
self.temp = 0
self.humid = 0
self.info_stream("Connection established.")
except:
self.error_stream('Connection could not be established.')
def init_device(self):
Device.init_device(self)
try:
config = get_config()
self.device = config.get(self.name)
switch_state(self, DevState.ON, "Ready!")
except Exception as e:
msg = "Exception initializing device: {0}".format(e)
self.error_stream(msg)
switch_state(self, DevState.FAULT, msg)
def init_device(self):
Device.init_device(self)
try:
config = get_config()
self.device = config.get(self.name)
switch_state(self, DevState.ON, "Ready!")
except Exception as e:
msg = "Exception initializing device: {0}".format(e)
self.error_stream(msg)
switch_state(self, DevState.FAULT, msg)
def init_device(self):
"""Initialises the attributes and properties of the Timer."""
Device.init_device(self)
# PROTECTED REGION ID(Timer.init_device) ENABLED START #
self.logger = logging.getLogger(__name__)
self._lock = threading.Lock()
self._dev_factory = DevFactory()
self._start_minutes = 0
self._start_seconds = 0
self.subscribed = False
self.set_state(DevState.OFF)
self.worker_thread = None
def init_device(self):
self.info_stream('Connecting to dummy...')
Device.init_device(self)
self.set_state(DevState.ON)
self.__temp = 300
self.__humid = 42.5
self.__shut = False
self.__humidparam = 100
self.__starttime = time.time()
self.__freq = 1
self.__pos = 0
self.info_stream('Connection to dummy established.')
async def init_device(self):
#self.lock = asyncio.Lock()
self.lock = threading.Lock()
self.task = None
self.error_count = 0
self.values = [float('NaN')] * 6
self.time = time.time() - self.READING_VALID_TIME - 1.0
self.timeval = tango.TimeVal.now()
self.set_state(DevState.INIT)
Device.init_device(self)
self.last_level = logging.INFO
# get device proxy
self.dp = tango.DeviceProxy(self.get_name())
# get all defined device properties
self.proplist = self.dp.get_property_list('*')
self.properties = self.dp.get_property(self.proplist)
# read port and addr properties
self.prt = self.get_device_property('port', 'COM1')
self.addr = self.get_device_property('addr', 6)
# config logger
#self.logger = logging.getLogger(__name__)
self.logger = logging.getLogger('%s:%s' %(self.prt, self.addr))
self.logger.propagate = False
self.logger.setLevel(logging.DEBUG)
self.f_str = '%(asctime)s,%(msecs)3d %(levelname)-7s [%(process)d:%(thread)d] %(filename)s ' \
'%(funcName)s(%(lineno)s) ' + ('%s:%s' %(self.prt, self.addr)) + ' - %(message)s'
log_formatter = logging.Formatter(self.f_str, datefmt='%H:%M:%S')
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
if not self.logger.hasHandlers():
self.logger.addHandler(console_handler)
# create TDKLambda device
self.tdk = AsyncTDKLambda(self.prt, self.addr, logger=self.logger)
await self.tdk.init()
# check if device OK
if self.tdk.initialized():
# add device to list
Async_TDKLambda_Server.devices.append(self)
# set state to running
self.set_state(DevState.RUNNING)
# set maximal values for set voltage and current
self.programmed_current.set_max_value(self.tdk.max_current)
self.programmed_voltage.set_max_value(self.tdk.max_voltage)
await self.read_all()
msg = '%s:%d TDKLambda %s created successfully' % (self.tdk.port, self.tdk.addr, self.tdk.id)
self.logger.info(msg)
self.info_stream(msg)
else:
self.set_state(DevState.FAULT)
msg = '%s:%d TDKLambda device created with errors' % (self.tdk.port, self.tdk.addr)
self.logger.error(msg)
self.error_stream(msg)
def init_device(self):
Device.init_device(self)
try:
if self.name:
config = get_config()
self.fuelcell = config.get(self.name)
else:
self.fuelcell = _FuelCell('Fuel Cell', dict(tcp=dict(url=self.url)))
self.set_state(DevState.ON)
self.set_status('Ready!')
except Exception as e:
self.set_state(DevState.FAULT)
self.set_status('Error:\n' + str(e))
def init_device(self):
Device.init_device(self)
self.debug_stream("In init_device() of controller")
self.group_dict = {}
if self.BackdoorPort:
print "Starting Backdoor server on port", self.BackdoorPort
server = BackdoorServer(('127.0.0.1', self.BackdoorPort),
banner="BlissAxisManager back door",
locals={'axis_manager': self})
gevent.spawn(server.serve_forever)
self.__backdoor_server = server
else:
print " no backdoor"
def init_device(self):
Device.init_device(self)
config = {
'serial_url': self.SerialUrl,
}
self._linkam = linkam(self.Name, config)
self._lock = lock.Semaphore()
self._filename = ""
self._profileData = [0.0,0.0,0.0]
self._linkam.subscribe(self._profileCompleteCallback)
if self._linkam is not None:
attr = self.get_device_attr().get_attr_by_name("temperature")
attr.set_write_value(self._linkam.getTemperature())
self.set_state(tango.DevState.ON)
def _dev_state(self):
""" This command gets the device state (stored in its device_state
data member) and returns it to the caller.
:param : none
:type: tango.DevVoid
:return: Device state
:rtype: tango.CmdArgType.DevState """
# self.debug_stream("In AmotionAxis dev_state()")
argout = tango.DevState.UNKNOWN
try:
_state = self.axis.state()
if _state.READY:
self.set_state(tango.DevState.ON)
elif _state.MOVING:
self.set_state(tango.DevState.MOVING)
elif _state.OFF:
self.set_state(tango.DevState.OFF)
else:
self.set_state(tango.DevState.FAULT)
self.set_status(_state.current_states())
self.attr_HardLimitLow_read = _state.LIMNEG
self.attr_HardLimitHigh_read = _state.LIMPOS
except:
self.set_state(tango.DevState.FAULT)
self.set_status(traceback.format_exc())
if argout != tango.DevState.ALARM:
Device.dev_state(self)
# print "dev_state %s" % self.get_state()
return self.get_state()
def init_device(self):
"""Initialise the device."""
Device.init_device(self)
def init_device(self):
Device.init_device(self)
def init_device(self):
Device.init_device(self)
kwargs = dict(url=self.url, pad=self.pad, sad=self.sad,
timeout=self.timeout, tmo=self.tmo)
self.gpib = _Gpib(**kwargs)
self.gpib.open()
def __init__(self, *args, **kwargs):
self._linkam = None
Device.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
self._nanoBpmProxy = None
self._xcontrolProxy = None
self._ycontrolProxy = None
self._centreId = None
Device.__init__(self, *args, **kwargs)
def __init__(self,*args,**kwargs) :
Device.__init__(self,*args,**kwargs)
self.__multiplexer = None
self.init_device()
def init_device(self):
self.debug_stream("In init_device() of axis")
Device.init_device(self)
# -v1
self.info_stream("INFO STREAM ON ++++++++++++++++++++++++++")
self.warn_stream("WARN STREAM ON ++++++++++++++++++++++++++")
self.error_stream("ERROR STREAM ON ++++++++++++++++++++++++++")
self.fatal_stream("FATAL STREAM ON ++++++++++++++++++++++++++")
# -v3 (-v == -v4)
self.debug_stream("DEBUG STREAM ON ++++++++++++++++++++++++++")
# force a get of axis and controller to update status in case of error
try:
axis = self.axis
controller = self.axis.controller
except:
traceback.print_exc()
elog.error("unable to get kontroller or axis")
self.set_status(traceback.format_exc())
_ctrl = 'UNKNOWN'
else:
m_attr = self.get_device_attr()
try:
m_attr.get_attr_by_name('Position').set_write_value(axis.position())
except:
pass
try:
m_attr.get_attr_by_name('Velocity').set_write_value(axis.velocity())
except:
pass
_ctrl = controller.get_class_name()
self.debug_stream("axis found : %s" % self._axis_name)
self._init_time = time.time()
self._t = time.time()
self.attr_Home_position_read = 0.0
self.attr_StepSize_read = 0.0
self.attr_Steps_per_unit_read = 0.0
self.attr_Acceleration_read = 1.0
self.attr_HardLimitLow_read = False
self.attr_HardLimitHigh_read = False
self.attr_Backlash_read = 0.0
self.attr_Sign_read = 1
self.attr_Offset_read = 0.0
self.attr_Tolerance_read = 0.0
self.attr_PresetPosition_read = 0.0
self.attr_FirstVelocity_read = 0.0
"""
self.attr_Steps_read = 0
self.attr_Position_read = 0.0
self.attr_Measured_Position_read = 0.0
self.attr_Home_side_read = False
"""
self.attr_trajpar_read = [[0.0]]
# To force update of state and status.
self._dev_state()
# elog.info(" %s" % self.axis.get_info())
elog.info("BlissAxisManager [%s] : \t" % _ctrl + bcolors.PINK + self._ds_name + bcolors.ENDC + "\t initialized")
def __init__(self, cl, name):
self._axis_name = name.split('/')[-1]
self._ds_name = name
Device.__init__(self, cl, name)
self.debug_stream("In __init__() of axis")
def __init__(self, *args, **kwargs):
self.__nanobpm = None
Device.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
self.gpib = None
Device.__init__(self, *args, **kwargs)
def init_device(self):
"""Initialise the device."""
Device.init_device(self)
time.sleep(0.1)
self.set_state(DevState.STANDBY)