def get_pi_comm(config, ctype=None, **opts):
"""
Returns PI communication channel from configuration.
See :func:`bliss.comm.util.get_comm` for more info.
"""
config = config.config_dict
if 'tcp' in config:
opts.setdefault('port', 50000)
opts.setdefault('timeout', 1)
try:
return get_comm(config, ctype=ctype, **opts)
except ValueError:
if config.has_key('host'):
warn("'host' keyword is deprecated. Use 'tcp' instead",
DeprecationWarning)
host = config.get("host")
opts.setdefault('port', 50000)
config = {'tcp': {'url': host}}
return get_comm(config, ctype=ctype, **opts)
elif config.has_key('serial_line'):
serial_line = self.config.get("serial_line")
warn("'serial_line' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
config = {'serial': {'url': serial_line}}
return get_comm(config, ctype=ctype, **opts)
raise ValueError('No communication channel found in config')
def get_pi_comm(config, ctype=None, **opts):
"""
Returns PI communication channel from configuration.
See :func:`bliss.comm.util.get_comm` for more info.
"""
config = config.config_dict
if 'tcp' in config:
opts.setdefault('port', 50000)
opts.setdefault('timeout', 1)
try:
return get_comm(config, ctype=ctype, **opts)
except ValueError:
if config.has_key('host'):
warn("'host' keyword is deprecated. Use 'tcp' instead",
DeprecationWarning)
host = config.get("host")
opts.setdefault('port', 50000)
config = {'tcp': {'url': host } }
return get_comm(config, ctype=ctype, **opts)
elif config.has_key('serial_line'):
serial_line = self.config.get("serial_line")
warn("'serial_line' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
config = {'serial': {'url': serial_line } }
return get_comm(config, ctype=ctype, **opts)
raise ValueError('No communication channel found in config')
def initialize(self):
try:
self.sock = get_comm(self.config.config_dict, ctype=TCP, port=4000)
except ValueError:
host = config.get("host")
warn("'host' keyword is deprecated. Use 'tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': host } }
self.sock = get_comm(comm_cfg, port=4000)
def initialize(self):
try:
self.sock = get_comm(self.config.config_dict, TCP, port=23)
except ValueError:
host = self.config.get("host")
warn("'host' keyword is deprecated. Use 'tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': host } }
self.sock = get_comm(comm_cfg, port=23)
if '=2' in self._write_read(None, "DRT", raw=True):
raise RuntimeError("Uncompatible closed-loop driver detected in daisy chain")
def initialize(self):
try:
self.sock = get_comm(self.config.config_dict, TCP, port=23)
except ValueError:
host = self.config.get("host")
warn("'host' keyword is deprecated. Use 'tcp' instead",
DeprecationWarning)
comm_cfg = {'tcp': {'url': host}}
self.sock = get_comm(comm_cfg, port=23)
if '=2' in self._write_read(None, "DRT", raw=True):
raise RuntimeError(
"Uncompatible closed-loop driver detected in daisy chain")
def initialize(self):
log.debug("initialize() called")
try:
self.sock = get_comm(self.config.config_dict, TCP)
except ValueError:
host = config.get("host")
port = int(config.get("port"))
warn("'host' and 'port' keywords are deprecated. " \
"Use 'tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': '{0}:{1}'.format(host, port)}}
self.sock = get_comm(comm_cfg)
log.info("initialize() create socket %s" % str(self.sock))
# read spurious 'd' character when connected
self.sock.readline(eol="\r")
def initialize(self):
log.debug("initialize() called")
try:
self.sock = get_comm(self.config.config_dict, TCP)
except ValueError:
host = config.get("host")
port = int(config.get("port"))
warn("'host' and 'port' keywords are deprecated. " \
"Use 'tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': '{0}:{1}'.format(host, port)}}
self.sock = get_comm(comm_cfg)
log.info("initialize() create socket %s" % str(self.sock))
# read spurious 'd' character when connected
self.sock.readline(eol="\r")
def __init__(self, name, config):
self._cache = {}
self._configured_address = int(config.get('address', TRANSPARENT_ADDR))
self._log = logging.getLogger('PressureTransmitter.{0}'.format(name))
self._comm_lock = gevent.lock.RLock()
self.counters = {}
self.debug = self._log.debug
self.config = config
self.name = name
self.comm = get_comm(config, baudrate=9600)
self.echo = config.get('echo', 1)
self.expected_serial_nb = config.get('serial_nb', None)
# Create counters
for counter_config in self.config.get('counters', []):
counter_name = counter_config['counter_name']
if hasattr(self, counter_name):
self._log.error('Skipped counter %r (controller already ' \
'has a member with that name)', counter_name)
continue
channel = counter_config.get('channel', 'P1')
counter = self.__create_counter(counter_name, channel=channel)
self.counters[counter_name] = counter
setattr(self, counter_name, counter)
self.initialize()
def initialize(self):
"""
Opens a single communication socket to the controller for all 1..6 axes.
"""
try:
self.sock = get_comm(self.config.config_dict, TCP, port=9760)
except ValueError:
host = self.config.get("host")
warn("'host' keyword is deprecated. Use 'tcp' instead",
DeprecationWarning)
if not host.startswith('command://'):
host = 'command://' + host
comm_cfg = {'tcp': {'url': host}}
self.sock = get_comm(comm_cfg, port=9760)
elog.debug("socket open : %r" % self.sock)
def __init__(self, name, config):
self._cache = {}
self._configured_address = int(config.get('address', TRANSPARENT_ADDR))
self._log = logging.getLogger('PressureTransmitter.{0}'.format(name))
self._comm_lock = gevent.lock.RLock()
self.counters = {}
self.debug = self._log.debug
self.config = config
self.name = name
self.comm = get_comm(config, baudrate=9600)
self.echo = config.get('echo', 1)
self.expected_serial_nb = config.get('serial_nb', None)
# Create counters
for counter_config in self.config.get('counters', []):
counter_name = counter_config['counter_name']
if hasattr(self, counter_name):
self._log.error('Skipped counter %r (controller already ' \
'has a member with that name)', counter_name)
continue
channel = counter_config.get('channel', 'P1')
counter = self.__create_counter(counter_name, channel=channel)
self.counters[counter_name] = counter
setattr(self, counter_name, counter)
self.initialize()
def __init__(self, config):
self._log = logging.getLogger('SHexapod')
self.config = config
self.eol = '\r\n'
self.comm = get_comm(config,
ctype=TCP,
port=self.DEFAULT_PORT,
eol=self.eol)
def initialize(self):
"""
Opens one socket for 2 channels.
"""
try:
self.serial = get_comm(self.config.config_dict, SERIAL, timeout=1)
self._status = "SERIAL communication configuration found"
elog.debug(self._status)
except ValueError:
try:
serial_line = self.config.get("serial_line")
warn(
"'serial_line' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
comm_cfg = {'serial': {'url': serial_line}}
self.serial = get_comm(comm_cfg, timeout=1)
except:
self._status = "Cannot find serial configuration"
elog.error(self._status)
try:
# should be : 'VSCANNER 01.02\r\n'
_ans = self.serial.write_readline("?VER\r\n")
self._status += "\ncommunication ok "
elog.debug(self._status + _ans)
except OSError:
_ans = "no ans"
self._status = sys.exc_info()[1]
elog.error(self._status)
except:
_ans = "no ans"
self._status = "communication error : cannot communicate with serial \"%s\"" % self.serial
elog.error(self._status)
traceback.print_exc()
try:
_ans.index("VSCANNER")
self._status += "VSCANNER found (substring VSCANNER found in answer to ?VER)."
except:
self._status = "communication error : no VSCANNER found on serial \"%s\"" % self.serial
elog.debug(self._status)
def initialize(self):
"""
Opens one socket for 2 channels.
"""
try:
self.serial = get_comm(self.config.config_dict, SERIAL, timeout=1)
self._status = "SERIAL communication configuration found"
elog.debug(self._status)
except ValueError:
try:
serial_line = self.config.get("serial_line")
warn("'serial_line' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
comm_cfg = {'serial': {'url': serial_line } }
self.serial = get_comm(comm_cfg, timeout=1)
except:
self._status = "Cannot find serial configuration"
elog.error(self._status)
try:
# should be : 'VSCANNER 01.02\r\n'
_ans = self.serial.write_readline("?VER\r\n")
self._status += "\ncommunication ok "
elog.debug(self._status + _ans)
except OSError:
_ans = "no ans"
self._status = sys.exc_info()[1]
elog.error(self._status)
except:
_ans = "no ans"
self._status = "communication error : cannot communicate with serial \"%s\"" % self.serial
elog.error(self._status)
traceback.print_exc()
try:
_ans.index("VSCANNER")
self._status += "VSCANNER found (substring VSCANNER found in answer to ?VER)."
except:
self._status = "communication error : no VSCANNER found on serial \"%s\"" % self.serial
elog.debug(self._status)
def test_get_comm():
config = dict()
with pytest.raises(ValueError):
get_comm_type(config)
config = dict(gpib={}, tcp={})
with pytest.raises(ValueError):
get_comm_type(config)
config = dict(tcp={})
with pytest.raises(KeyError):
get_comm(config)
config = dict(tcp={})
with pytest.raises(TypeError):
get_comm(config, ctype=SERIAL)
config = dict(tcp=dict(url='toto'))
with pytest.raises(KeyError) as err:
get_comm(config)
# should work always since tcp uses lazy connection
tcp = get_comm(config, port=5000)
assert tcp._host == 'toto'
assert tcp._port == 5000
config = dict(tcp=dict(url='toto:4999'))
tcp = get_comm(config, port=5000)
assert tcp._host == 'toto'
assert tcp._port == 4999
config = dict(gpib=dict(url='enet://toto'))
gpib = get_comm(config)
assert gpib.gpib_type == gpib.ENET
config = dict(serial=dict(url='/dev/tty0', eol='\r'))
sl = get_comm(config, baudrate=38400, eol='\r\n')
assert sl._port == config['serial']['url']
assert sl._serial_kwargs['baudrate'] == 38400
assert sl._eol == config['serial']['eol']
def initialize(self):
config = self.config.config_dict
if get_comm_type(config) == UDP:
opt = {'port':5001,'eol':';'}
else: # SERIAL
opt = {'baudrate':115200,'eol':';'}
self._cnx = get_comm(config,**opt)
self._elmostate = AxisState()
for state,human in (('SLAVESWITCH','Slave switch activate'),
('INHIBITSWITCH','Inhibit switch active'),
('CLOSEDLOOPOPEN','Closed loop open'),
('DRIVEFAULT','Problem into the drive')):
self._elmostate.create_state(state,human)
def initialize(self):
config = self.config.config_dict
if get_comm_type(config) == UDP:
opt = {'port': 5001, 'eol': ';'}
else: # SERIAL
opt = {'baudrate': 115200, 'eol': ';'}
self._cnx = get_comm(config, **opt)
self._elmostate = AxisState()
for state, human in (('SLAVESWITCH', 'Slave switch activate'),
('INHIBITSWITCH', 'Inhibit switch active'),
('CLOSEDLOOPOPEN', 'Closed loop open'),
('DRIVEFAULT', 'Problem into the drive')):
self._elmostate.create_state(state, human)
def __init__(self, name, config):
self.log = logging.getLogger('{0}({1})'.format(
type(self).__name__, name))
self.config = config
self.name = name
self.comm = get_comm(config, eol='\r')
self.comm.flush()
form = []
self.__formatter = OrderedDict()
for counter_config in config.get('counters', ()):
channel = counter_config['channel']
quantity = QUANTITIES[channel]
counter_config['unit'] = quantity['unit']
self.__formatter[channel] = quantity
form.append(quantity.formatter())
self.formatter = ' #t '.join(form) + ' #r'
def __init__(self, name, config_tree):
self.name = name
comm_type = None
try:
comm_type = get_comm_type(config_tree)
key = 'serial' if comm_type == SERIAL else 'tcp'
config_tree[key]['url'] # test if url is available
comm_config = config_tree
except:
if "serial" in config_tree:
comm_type = SERIAL
comm_config = dict(serial=dict(url=config_tree['serial']))
warn("'serial: <url>' is deprecated. " \
"Use 'serial: url: <url>' instead", DeprecationWarning)
elif "socket" in config_tree:
comm_type = TCP
comm_config = dict(tcp=dict(url=config_tree['socket']))
warn("'socket: <url>' is deprecated. " \
"Use 'tcp: url: <url>' instead", DeprecationWarning)
else:
raise RuntimeError(
"opiom: need to specify a communication url")
if comm_type not in (SERIAL, TCP):
raise TypeError('opiom: invalid communication type %r' % comm_type)
self._cnx = get_comm(comm_config, ctype=comm_type, timeout=3)
self._cnx.flush()
self.__program = config_tree['program']
self.__base_path = config_tree.get('opiom_prg_root', OPIOM_PRG_ROOT)
self.__debug = False
try:
msg = self.comm("?VER", timeout=50e-3)
except serial.SerialTimeout:
msg = self.comm("?VER", timeout=50e-3)
if not msg.startswith('OPIOM'):
raise IOError("No opiom connected at %s" % serial)
self.comm("MODE normal")
def __init__(self,name,config_tree):
self.name = name
comm_type = None
try:
comm_type = get_comm_type(config_tree)
key = 'serial' if comm_type == SERIAL else 'tcp'
config_tree[key]['url'] # test if url is available
comm_config = config_tree
except:
if "serial" in config_tree:
comm_type = SERIAL
comm_config = dict(serial=dict(url=config_tree['serial']))
warn("'serial: <url>' is deprecated. " \
"Use 'serial: url: <url>' instead", DeprecationWarning)
elif "socket" in config_tree:
comm_type = TCP
comm_config = dict(tcp=dict(url=config_tree['socket']))
warn("'socket: <url>' is deprecated. " \
"Use 'tcp: url: <url>' instead", DeprecationWarning)
else:
raise RuntimeError("opiom: need to specify a communication url")
if comm_type not in (SERIAL, TCP):
raise TypeError('opiom: invalid communication type %r' % comm_type)
self._cnx = get_comm(comm_config, ctype=comm_type, timeout=3)
self._cnx.flush()
self.__program = config_tree['program']
self.__base_path = config_tree.get('opiom_prg_root',OPIOM_PRG_ROOT)
self.__debug = False
try:
msg = self.comm("?VER",timeout=50e-3)
except serial.SerialTimeout:
msg = self.comm("?VER",timeout=50e-3)
if not msg.startswith('OPIOM') :
raise IOError("No opiom connected at %s" % serial)
self.comm("MODE normal")
def __init__(self, name, config):
""" FireFlash hardware controller.
name -- the controller's name
config -- controller configuration,
in this dictionary we need to have:
command_url -- url of the command port
control_url -- url of the control port
"""
# Status bits for getStatus command
self.StatusBits = {'IDLE': 0, 'BUSY': 1, 'REMOTE': 2, 'STREAMING': 4}
# Status bits for Remote Data Toggle
self.ToggleBits = {'OFF': 0, 'XFIT': 1, 'YFIT': 2, 'COG': 4}
try:
self.command_socket = get_comm(self.config['command'], ctype=TCP)
except KeyError:
command_url = config["command_url"]
warn("'command_url' keyword is deprecated." \
" Use 'command: tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': command_url}}
self.command_socket = get_comm(comm_cfg)
try:
self.control_socket = get_comm(self.config['control'], ctype=TCP)
except KeyError:
control_url = config["control_url"]
warn("'control_url' keyword is deprecated." \
" Use 'control: tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': control_url}}
self.control_socket = get_comm(comm_cfg)
# Commands ready packed in network byte order
self.commandReset = struct.pack(">H", 0xAA00)
self.commandInterrupt = struct.pack(">H", 0xAA01)
self.commandStatus = struct.pack(">H", 0xAA02)
self.commandDataToggle = struct.pack(">H", 0xAA03)
self.commandGetDeviceInfo = struct.pack(">H", 0xAA20)
self.commandSetConfig = struct.pack(">H", 0xAA22)
self.commandGetConfig = struct.pack(">H", 0xAA21)
self.commandGetIntTime = struct.pack(">H", 0xAA23)
self.commandSetIntTime = struct.pack(">H", 0xAA24)
self.commandSetParams = struct.pack(">H", 0xAA26)
self.commandGetParams = struct.pack(">H", 0xAA27)
self.commandReadImage16 = struct.pack(">H", 0xAA30)
self.commandReadImage8 = struct.pack(">H", 0xAA31)
self.commandReadDark16 = struct.pack(">H", 0xAA32)
self.commandAve16Sum32 = struct.pack(">H", 0xAA33)
self.commandContinuous = struct.pack(">H", 0xAA37)
self.commandStreamData = struct.pack(">H", 0xAA3A)
self._errorCode2string = {
self.NO_ERROR: "No Error",
self.CODE1: "Error parsing .ini file",
self.CODE2: "Could not establish network connection",
self.CODE3: "Network data transfer failed",
self.CODE4: "Incorrect FPGA type",
self.CODE5: "Invalid argument or config param error",
self.CODE6: "I^C-bus communication error",
self.CODE7: "Memory initialization error",
self.CODE8: "I^C-bus initialization error"
}
# Device Info structure keys
self._deviceInfoKeys = [
'ProcessorType', 'ProcessorVersion', 'FPGAType', 'FPGAVersion',
'BoardType', 'BoardVersion', 'BuidYear', 'BuildMonth', 'Buildday',
'BuildHour', 'BuildMinute', 'BuildSecond', 'SWMajor', 'SWMinor',
'SWbuild', 'FirmWare Major', 'FirmWareMinor', 'FirmWareBuild'
', BoardID'
]
# Device configuration parameter keys
self._deviceConfigKeys = [
'Settings', 'Gain', 'Offset', 'LineIntTime', 'YEnd',
'FrameIntTime', 'YStart', 'XStart', 'XEnd', 'AdcPhase',
'SubtractDarkImage'
]
#Image Descriptor keys
self._imageDescriptorKeys = [
'FrameNb', 'IntegrationTime', 'XSize', 'YSize', 'InternalPtr'
]
self._quadConfigKeys = [
'XCentre', 'YCentre', 'WinStartX', 'WinEndX', 'WinStartY',
'WinEndY'
]
self._sensorConfigKeys = ['YSize', 'DarkImageSubtract']
#device parameter keys
self._deviceParameterKeys = [
'configurationKeys', 'DAC0Keys', 'DAC1Keys', 'DAC2keys',
'DAC3Keys', 'fitParameterKeys', 'verticalFitResultCriteria',
'horizontalFitResultCriteria'
]
self._configurationKeys = [
'Control', 'XStart', 'YStart', 'Width', 'Height', 'Gain',
'SensorFineOffset', 'SensorCourseOffset', 'IntegrationTime',
'ImageClock', 'AdcPhase', 'Orientation', 'RampInc'
]
self._DAC0Keys = self._DAC1Keys = self._DAC2Keys = self._DAC3Keys = [
'MinOutVoltage', 'MaxOutVoltage', 'MinDACCode', 'MaxDACCode',
'Action;'
]
self._fitParameterKeys = [
'MaxDeltaChiSq', 'Threshold', 'MaxIter', 'FilterSpan', 'FilterCtrl'
]
self._fitResultCriteriaKeys = [
'MaxWidth', 'MinWidth', 'MinRSQ', 'MinAmp', 'CalibCoeff',
'CalibOffset'
]
self._logger = logging.getLogger("NanoBpmCtrl.NanoBpm")
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
self._controlWord = 0
self._nbFramesToSum = 8
self._thread = None
self._lock = lock.Semaphore()
self._remoteDataSelector = 0
self._frameNbAcquired = -1
self._actionByte = 0
self._imageDescriptor = None
self._configurationParameters = None
self._dac0Parameters = None
self._dac1Parameters = None
self._dac2Parameters = None
self._dac3Parameters = None
self._fitParameters = None
self._vertFitResultParameters = None
self._horFitResultParameters = None
self._deviceInfo = self.getDeviceInfo()
self._deviceConfig = self.getDeviceConfig()
self._deviceParameters = self.getDeviceParameters()
# This defines the quad window as the full Image - We do not use the Quad's ROI
self._quadConfig = OrderedDict(
zip(self._quadConfigKeys,
((self._deviceConfig['XEnd'] - self._deviceConfig['XStart']) /
2,
(self._deviceConfig['YEnd'] - self._deviceConfig['YStart']) /
2, self._deviceConfig['XStart'], self._deviceConfig['XEnd'],
self._deviceConfig['YStart'], self._deviceConfig['YEnd'])))
def initialize(self):
"""
"""
self.comm = get_comm(self.config)
def __init__(self, config, port=None):
port = self.PORT if port is None else port
self._req_nb = 0
self._sock = get_comm(config, ctype=TCP, port=port, eol='\r\n')
def __init__(self, name, config):
""" FireFlash hardware controller.
name -- the controller's name
config -- controller configuration,
in this dictionary we need to have:
command_url -- url of the command port
control_url -- url of the control port
"""
# Status bits for getStatus command
self.StatusBits = {'IDLE':0, 'BUSY':1, 'REMOTE':2, 'STREAMING':4}
# Status bits for Remote Data Toggle
self.ToggleBits = {'OFF':0,'XFIT':1,'YFIT':2,'COG':4}
try:
self.command_socket = get_comm(self.config['command'], ctype=TCP)
except KeyError:
command_url = config["command_url"]
warn("'command_url' keyword is deprecated." \
" Use 'command: tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': command_url } }
self.command_socket = get_comm(comm_cfg)
try:
self.control_socket = get_comm(self.config['control'], ctype=TCP)
except KeyError:
control_url = config["control_url"]
warn("'control_url' keyword is deprecated." \
" Use 'control: tcp' instead", DeprecationWarning)
comm_cfg = {'tcp': {'url': control_url } }
self.control_socket = get_comm(comm_cfg)
# Commands ready packed in network byte order
self.commandReset = struct.pack(">H",0xAA00)
self.commandInterrupt = struct.pack(">H",0xAA01)
self.commandStatus = struct.pack(">H",0xAA02)
self.commandDataToggle = struct.pack(">H",0xAA03)
self.commandGetDeviceInfo = struct.pack(">H",0xAA20)
self.commandSetConfig = struct.pack(">H",0xAA22)
self.commandGetConfig = struct.pack(">H",0xAA21)
self.commandGetIntTime = struct.pack(">H",0xAA23)
self.commandSetIntTime = struct.pack(">H",0xAA24)
self.commandSetParams = struct.pack(">H",0xAA26)
self.commandGetParams = struct.pack(">H",0xAA27)
self.commandReadImage16 = struct.pack(">H",0xAA30)
self.commandReadImage8 = struct.pack(">H",0xAA31)
self.commandReadDark16 = struct.pack(">H",0xAA32)
self.commandAve16Sum32 = struct.pack(">H",0xAA33)
self.commandContinuous = struct.pack(">H",0xAA37)
self.commandStreamData = struct.pack(">H",0xAA3A)
self._errorCode2string = {
self.NO_ERROR : "No Error",
self.CODE1 : "Error parsing .ini file",
self.CODE2 : "Could not establish network connection",
self.CODE3 : "Network data transfer failed",
self.CODE4 : "Incorrect FPGA type",
self.CODE5 : "Invalid argument or config param error",
self.CODE6 : "I^C-bus communication error",
self.CODE7 : "Memory initialization error",
self.CODE8 : "I^C-bus initialization error"
}
# Device Info structure keys
self._deviceInfoKeys = ['ProcessorType', 'ProcessorVersion', 'FPGAType', 'FPGAVersion', 'BoardType', 'BoardVersion',
'BuidYear', 'BuildMonth', 'Buildday', 'BuildHour', 'BuildMinute', 'BuildSecond', 'SWMajor', 'SWMinor', 'SWbuild',
'FirmWare Major', 'FirmWareMinor', 'FirmWareBuild'', BoardID']
# Device configuration parameter keys
self._deviceConfigKeys = ['Settings', 'Gain', 'Offset', 'LineIntTime', 'YEnd',
'FrameIntTime', 'YStart', 'XStart', 'XEnd', 'AdcPhase', 'SubtractDarkImage']
#Image Descriptor keys
self._imageDescriptorKeys = ['FrameNb', 'IntegrationTime', 'XSize', 'YSize', 'InternalPtr']
self._quadConfigKeys = ['XCentre', 'YCentre', 'WinStartX', 'WinEndX', 'WinStartY', 'WinEndY']
self._sensorConfigKeys = ['YSize', 'DarkImageSubtract']
#device parameter keys
self._deviceParameterKeys = ['configurationKeys', 'DAC0Keys', 'DAC1Keys', 'DAC2keys', 'DAC3Keys', 'fitParameterKeys',
'verticalFitResultCriteria', 'horizontalFitResultCriteria']
self._configurationKeys = ['Control', 'XStart', 'YStart', 'Width', 'Height', 'Gain', 'SensorFineOffset', 'SensorCourseOffset',
'IntegrationTime', 'ImageClock', 'AdcPhase', 'Orientation', 'RampInc']
self._DAC0Keys = self._DAC1Keys = self._DAC2Keys = self._DAC3Keys = ['MinOutVoltage', 'MaxOutVoltage', 'MinDACCode',
'MaxDACCode', 'Action;']
self._fitParameterKeys = ['MaxDeltaChiSq', 'Threshold', 'MaxIter', 'FilterSpan', 'FilterCtrl']
self._fitResultCriteriaKeys = ['MaxWidth', 'MinWidth', 'MinRSQ', 'MinAmp', 'CalibCoeff', 'CalibOffset']
self._logger = logging.getLogger("NanoBpmCtrl.NanoBpm")
logging.basicConfig(level=logging.INFO)
self._logger.setLevel(logging.DEBUG)
self._controlWord = 0
self._nbFramesToSum = 8
self._thread = None
self._lock = lock.Semaphore()
self._remoteDataSelector = 0
self._frameNbAcquired = -1
self._actionByte = 0
self._imageDescriptor = None
self._configurationParameters = None
self._dac0Parameters = None
self._dac1Parameters = None
self._dac2Parameters = None
self._dac3Parameters = None
self._fitParameters = None
self._vertFitResultParameters = None
self._horFitResultParameters = None
self._deviceInfo = self.getDeviceInfo()
self._deviceConfig = self.getDeviceConfig()
self._deviceParameters = self.getDeviceParameters()
# This defines the quad window as the full Image - We do not use the Quad's ROI
self._quadConfig = OrderedDict(zip(self._quadConfigKeys, ((self._deviceConfig['XEnd'] - self._deviceConfig['XStart']) / 2,
(self._deviceConfig['YEnd'] - self._deviceConfig['YStart']) / 2, self._deviceConfig['XStart'],
self._deviceConfig['XEnd'], self._deviceConfig['YStart'], self._deviceConfig['YEnd'])))
def __init__(self, name, config):
""" Linkam controller with either hot stage or dsc stage
config_-- controller configuration,
"""
self.name = name
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=10)
try:
self._cnx = get_comm(config,
SERIAL,
baudrate=19200,
eol='\r',
timeout=10)
except ValueError:
if "serial_url" in config:
warn(
"'serial_url' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
comm_cfg = {'serial': {'url': config['serial_url']}}
self._cnx = get_comm(comm_cfg,
baudrate=19200,
eol='\r',
timeout=10)
else:
raise ValueError, "Must specify serial"
#Possible values of the status byte
self.STOPPED = 0x1
self.HEATING = 0x10
self.COOLING = 0x20
self.HOLDINGLIMIT = 0x30
self.HOLDINGTIME = 0x40
self.HOLDINGTEMP = 0x50
self.StatusToString = {
self.STOPPED: "Stopped",
self.HEATING: "Heating",
self.COOLING: "Cooling",
self.HOLDINGLIMIT: "Holding the limit time",
self.HOLDINGTEMP: "Holding the current temperature",
}
# Linkam error codes
self.LINKAM_COOLING_TOOFAST = 0x01
self.LINKAM_OPEN_CIRCUIT = 0x02
self.LINKAM_POWER_SURGE = 0x04
self.LINKAM_EXIT_300 = 0x08
self.LINKAM_LINK_ERROR = 0x20
self.LINKAM_OK = 0x80
self.ErrorToString = {
self.LINKAM_COOLING_TOOFAST: "Cooling too fast",
self.LINKAM_OPEN_CIRCUIT:
"Stage not connected or sensor is open circuit",
self.LINKAM_POWER_SURGE: "Current protection due to overload",
self.LINKAM_EXIT_300:
"No Exit (300 TS 1500 tried to exit profile at a temperature > 300 degrees)",
self.LINKAM_LINK_ERROR:
"Problems with RS-232 data transmission - RESET Linkam !",
self.LINKAM_OK: "OK"
}
self._maximumTemp = config.get('max_temp', 1500.0)
self._minimumTemp = config.get('min_temp', -196.0)
self._model = config.get('model', "T95")
self._profile_task = None
self._lock = lock.Semaphore()
self._hasDSC = self._hasDscStage()
(self._state, self._errCode, _, _) = self._getStatus()
self._temperature = self.getTemperature()
self._limit = self._temperature
self._rampNb = 1
self._rate = 10
self._holdTime = 1
self._dscSamplingRate = 0.3
self._statusString = None
self._pumpSpeed = 0
self._dscValue = 0.
self._startingRamp = 1
self._pollTime = 0.1
self._pipe = os.pipe()
self._hold = True
self._tstamp = 0
self._profileCompleteCallback = None
self._profileData = [[]]
def __init__(self, name, config):
""" Linkam controller with either hot stage or dsc stage
config_-- controller configuration,
"""
self.name = name
self._logger = logging.getLogger(str(self))
logging.basicConfig(level=10)
try:
self._cnx = get_comm(config, SERIAL, baudrate=19200, eol='\r',
timeout=10)
except ValueError:
if "serial_url" in config:
warn("'serial_url' keyword is deprecated. Use 'serial' instead",
DeprecationWarning)
comm_cfg = {'serial': {'url': config['serial_url'] }}
self._cnx = get_comm(comm_cfg, baudrate=19200, eol='\r', timeout=10)
else:
raise ValueError, "Must specify serial"
#Possible values of the status byte
self.STOPPED = 0x1
self.HEATING = 0x10
self.COOLING = 0x20
self.HOLDINGLIMIT = 0x30
self.HOLDINGTIME = 0x40
self.HOLDINGTEMP = 0x50
self.StatusToString = {
self.STOPPED: "Stopped",
self.HEATING: "Heating",
self.COOLING: "Cooling",
self.HOLDINGLIMIT: "Holding the limit time",
self.HOLDINGTEMP: "Holding the current temperature",
}
# Linkam error codes
self.LINKAM_COOLING_TOOFAST = 0x01
self.LINKAM_OPEN_CIRCUIT = 0x02
self.LINKAM_POWER_SURGE = 0x04
self.LINKAM_EXIT_300 = 0x08
self.LINKAM_LINK_ERROR = 0x20
self.LINKAM_OK = 0x80
self.ErrorToString = {
self.LINKAM_COOLING_TOOFAST: "Cooling too fast",
self.LINKAM_OPEN_CIRCUIT: "Stage not connected or sensor is open circuit",
self.LINKAM_POWER_SURGE: "Current protection due to overload",
self.LINKAM_EXIT_300: "No Exit (300 TS 1500 tried to exit profile at a temperature > 300 degrees)",
self.LINKAM_LINK_ERROR: "Problems with RS-232 data transmission - RESET Linkam !",
self.LINKAM_OK: "OK"
}
self._maximumTemp = config.get('max_temp', 1500.0)
self._minimumTemp = config.get('min_temp', -196.0)
self._model = config.get('model', "T95")
self._profile_task = None
self._lock = lock.Semaphore()
self._hasDSC = self._hasDscStage()
(self._state, self._errCode, _, _) = self._getStatus()
self._temperature = self.getTemperature()
self._limit = self._temperature
self._rampNb = 1
self._rate = 10
self._holdTime = 1
self._dscSamplingRate = 0.3;
self._statusString = None
self._pumpSpeed = 0
self._dscValue = 0.
self._startingRamp = 1
self._pollTime = 0.1
self._pipe = os.pipe()
self._hold = True;
self._tstamp=0
self._profileCompleteCallback = None
self._profileData = [[]]
def initialize(self):
"""
"""
self.comm = get_comm(self.config)
def __init__(self, config):
self._log = logging.getLogger('SHexapod')
self.config = config
self.eol = '\r\n'
self.comm = get_comm(config, ctype=TCP, port=self.DEFAULT_PORT,
eol=self.eol)
