def collect(self,
num_samples,
trigger,
timeout=5,
is_randomized=False,
is_alternate_bit=False):
self.controller.dc890_flush()
num_samples *= self.num_channels
funcs.start_collect(self, num_samples, trigger, timeout)
self.vprint('Data collect done.')
self.controller.dc890_flush()
self.vprint('Reading data')
if self.bytes_per_sample == 2:
num_bytes, raw_data = self.controller.data_receive_uint16_values(
end=num_samples)
if num_bytes != num_samples * 2:
raise errs.HardwareError("Didn't get all bytes")
else:
num_bytes, raw_data = self.controller.data_receive_uint32_values(
end=num_samples)
if num_bytes != num_samples * 4:
raise errs.HardwareError("Didn't get all bytes")
self.vprint('Data read done')
data = self.fix_data(raw_data, is_randomized, is_alternate_bit)
return funcs.scatter_data(data, self.num_channels)
def send_data(self, data):
num_samples = len(data)
num_samples_reg_value = Ltc2000._SIZE_DICTIONARY.get(num_samples)
if num_samples > self.expected_max_val or num_samples_reg_value is None:
raise (errs.NotSupportedError(
"Data Length Not Supported (Must be a power of 2 between " +
self.range_string))
self.vprint("Reading PLL status")
pll_status = self.controller.hs_fpga_read_data_at_address(
Ltc2000._FPGA_STATUS_REG)
if self.expected_pll_status != pll_status:
raise (errs.HardwareError('FPGA PLL status was bad'))
self.vprint("PLL status is okay")
time.sleep(0.1)
self.controller.hs_fpga_write_data_at_address(
Ltc2000._FPGA_CONTROL_REG, num_samples_reg_value)
if self.is_little_endian:
self.controller.data_set_low_byte_first()
else:
self.controller.data_set_high_byte_first()
self.controller.hs_set_bit_mode(consts.HS_BIT_MODE_FIFO)
self.vprint("Sending data")
num_bytes_sent = self.controller.data_send_uint16_values(data)
self.controller.hs_set_bit_mode(consts.HS_BIT_MODE_MPSSE)
if num_bytes_sent != num_samples * 2:
raise (errs.HardwareError("Not all data was sent."))
self.vprint("All data was sent (" + str(num_bytes_sent) + " bytes)")
def get_controller_info_by_eeprom(controller_type, dc_number, eeprom_id_size,
vprint):
# find demo board with correct ID
vprint('Looking for a controller board')
info_list = comm.list_controllers(controller_type)
if info_list is None:
raise (err.HardwareError('No controller boards found'))
for info in comm.list_controllers(controller_type):
with comm.Controller(info) as controller:
eeprom_id = controller.eeprom_read_string(eeprom_id_size)
if dc_number in eeprom_id:
vprint('Found the ' + dc_number + ' demoboard')
return info
raise (err.HardwareError('Could not find a compatible device'))
def _check_data(self, data):
seq_len = len(self.spi_reg_values)
if self.is_high_speed:
for i in range(0, len(data), seq_len):
if (data[i] & 0x100) == 0:
raise errs.HardwareError(
"Detected incorrect config in data")
else:
check_idx = 0
for d in data:
if (d >> 1) & 0x7F != self.spi_reg_values[check_idx] & 0x7F:
raise errs.HardwareError(
"Detected incorrect config in data")
check_idx = (check_idx + 1) % seq_len
def _get_data_and_check_df(self, data):
# figure out the expected metadata
df_code = self.df_map[self.df]
check = (((df_code * 2 + 8) << 4) | 0x05) << 24
check_mask = 0xFF000000
# figure out which is data and which is metadata
data_0 = data[0::2]
data_1 = data[1::2]
data = data_0
meta = data_1
for d0, d1 in zip(data_0, data_1):
if (d0 & check_mask) != check:
# data_0 is the data
break
elif (d1 & check_mask) != check:
data = data_1
meta = data_0
break
# check metadata
for m in meta:
if (m & check_mask) != check:
raise errs.HardwareError("Invalid metadata")
return funcs.uint32_to_int32(data)
def _get_data_and_check_df(self, data):
# figure out the expected metadata
if self.filter_type == AVERAGING_FILTER:
check = AVERAGING_FILTER << 24
check |= (self.df - 1) << 10
check_mask = 0xFFFFC00
else:
df_code = self.df_map[self.df]
check = (df_code << 28) | (self.filter_type << 24)
check_mask = 0xFF000000
# figure out which is data and which is metadata
data_0 = data[0::2]
data_1 = data[1::2]
data = data_0
meta = data_1
for d0, d1 in zip(data_0, data_1):
if (d0 & check_mask) != check:
# data_0 is the data
break
elif (d1 & check_mask) != check:
data = data_1
meta = data_0
break
# check metadata
for m in meta:
if (m & check_mask) != check:
raise errs.HardwareError("Invalid metadata")
return funcs.uint32_to_int32(data)
def start_collect(controller_board, num_samples, trigger, timeout=5):
controller_board.controller.data_start_collect(num_samples, trigger)
SLEEP_TIME = 0.2
for i in range(int(math.ceil(timeout / SLEEP_TIME))):
if controller_board.controller.data_is_collect_done():
return
time.sleep(SLEEP_TIME)
raise err.HardwareError('Data collect timed out (missing clock?)')
def _format_data(self, data, meta_data):
osr_1 = self.osr - 1
raw_data = [d & 0xFFFFFF for d in data]
osr = [((d0 >> 24) & 0xFF) | ((d1 >> 16) & 0xFF00)
for d0, d1 in zip(data, meta_data)]
for o in osr:
if o != osr_1:
raise errs.HardwareError("Invalid OSR data")
return raw_data
def list_controllers(controller_type):
"""Returns a list of ControllerInfo structures
Looks for all attached controllers matching controller_type and puts their info in the list
controller_type can be a bitwise OR combination of TYPE_* values
"""
num_controllers = ct.c_int()
if _dll.LccGetNumControllers(ct.c_int(controller_type), ct.c_int(100),
ct.byref(num_controllers)) != 0:
raise errs.HardwareError("Could not create controller info list")
num_controllers = num_controllers.value
if num_controllers == 0:
return None
controller_info_list = (ControllerInfo * num_controllers)()
if _dll.LccGetControllerList(ct.c_int(controller_type),
controller_info_list, num_controllers) != 0:
raise errs.HardwareError(
"Could not get device info list, or no device found")
return controller_info_list
def _connect(self):
# Open communication to the demo board
self.vprint("Looking for Controller")
for info in comm.list_controllers(consts.TYPE_HIGH_SPEED):
description = info.get_description()
if self.expected_description in description:
self.vprint("Found a possible setup")
self.controller = comm.Controller(info)
return
raise (errs.HardwareError('Could not find a compatible device'))
def _get_data(self, data):
num_samples = len(data) / 2
start_sample = self._get_start_sample(data[0])
data = data[start_sample:num_samples + start_sample]
for i in range(len(data)):
if data[i] & 0x7 != i % self.num_channels:
raise errs.HardwareError(
"Unexpected channel number in metadata")
data[i] = data[i] >> 16
return data
def _init_controller(self, spi_reg_values):
self.controller.hs_set_bit_mode(consts.HS_BIT_MODE_MPSSE)
self.controller.hs_fpga_toggle_reset()
# Read FPGA ID register
id = self.controller.hs_fpga_read_data_at_address(Ltc2000._FPGA_ID_REG)
self.vprint("FPGA Load ID: 0x{:04X}".format(id))
if self.expected_id != id:
raise (errs.HardwareError('Wrong FPGA Load'))
self.controller.hs_fpga_write_data_at_address(Ltc2000._FPGA_DAC_PD,
0x01)
self.set_spi_registers(spi_reg_values)
def read_3_byte_values(self, num_samples):
num_bytes, raw_data = self.controller.data_receive_bytes(
end=num_samples * 3)
if num_bytes != num_samples * 3:
raise errs.HardwareError("Didn't get all bytes")
data = []
for i in range(num_samples):
d = raw_data[3 * i] << 16
d |= raw_data[3 * i + 1] << 8
d |= raw_data[3 * i + 2]
data.append(d)
return data
def __init__(self, controller_info):
"""Initialize the controller described by controller_info
"""
self._handle = ct.c_void_p(None)
self._c_error_buffer = ct.create_string_buffer(
consts.ERROR_BUFFER_SIZE)
self._c_array = None
self._c_array_type = "none"
self._dll = _dll
if self._dll.LccInitController(ct.byref(self._handle),
ct.byref(controller_info)) != 0:
raise errs.HardwareError("Error initializing the device")
def _get_data_and_check_df(self, data):
# figure out the expected metadata
df_code = self.df_map[self.df]
check = ((df_code + 2) << 4) | 0x06
check_mask = 0x000000FF
# check metadata
for d in data:
if (d & check_mask) != check:
raise errs.HardwareError("Invalid metadata")
return funcs.fix_data([d >> 8 for d in data], 24, 24, True)
def _call(self, func_name, *args):
func = getattr(self._dll, 'Lcc' + func_name)
error_code = func(self._handle, *args)
if error_code != 0:
self._dll.LccGetErrorInfo(self._handle, self._c_error_buffer,
consts.ERROR_BUFFER_SIZE)
if error_code == -1:
raise errs.HardwareError(self._c_error_buffer.value)
elif error_code == -2:
raise ValueError(self._c_error_buffer.value)
elif error_code == -3:
raise errs.LogicError(self._c_error_buffer.value)
elif error_code == -4:
raise errs.NotSupportedError(self._c_error_buffer.value)
else:
raise RuntimeError(self._c_error_buffer.value)
def collect(
self,
num_samples,
trigger,
timeout=5,
is_randomized=False,
is_alternate_bit=False,
):
num_samples = num_samples * self.num_channels
funcs.start_collect(self, num_samples, trigger, timeout)
self.vprint('Data collect done.')
self.vprint('Reading data')
num_bytes, raw_data = self.controller.data_receive_uint16_values(
end=num_samples)
if num_bytes != num_samples * 2:
raise errs.HardwareError("Didn't get all bytes")
self.vprint('Data read done')
data = funcs.fix_data(raw_data, self.num_bits, self.alignment,
self.is_bipolar, is_randomized, is_alternate_bit)
return funcs.scatter_data(data, self.num_channels)
if verbose:
print "Basic LTC2123 DC1974 Interface Program"
# Open communication to the demo board
descriptions = [
'LTC UFO Board', 'LTC Communication Interface', 'LTC2000 Demoboard',
'LTC2000, DC2085A-A'
]
device_info = None
for info in comm.list_controllers(consts.TYPE_HIGH_SPEED):
if info.get_description() in descriptions:
device_info = info
break
if device_info is None:
raise (errs.HardwareError('Could not find a compatible device'))
while ((runs < 1 or continuous == True) and runs_with_errors < 100000):
runs += 1
# if(verbose != 0):
print "LTC2123 Interface Program"
print "Run number: " + str(runs)
print "\nRuns with errors: " + str(runs_with_errors) + "\n"
if (runs_with_uncaught_errors > 0):
print "***\n***\n***\n*** UNCAUGHT error count: " + str(runs_with_uncaught_errors) + \
"!\n***\n***\n***\n"
################################################
# Configuration Flow Step 6: Issue Reset Pulse
################################################
def _get_data_subset(self, data):
seq_len = len(self.spi_reg_values)
for i in range(seq_len):
if (data[i] & 0x100) != 0:
return data[i:(len(data) / 2 + i)]
raise errs.HardwareError("Could not find correct config from data")