class Controller(NysaBaseController):
@staticmethod
def get_name():
return APP_NAME
@staticmethod
def get_driver():
return DRIVER
def __init__(self):
super (Controller, self).__init__()
self.actions = LogicAnalyzerActions()
self.actions.trigger_en_changed.connect(self.trigger_enable_changed)
self.actions.trigger_pol_changed.connect(self.trigger_pol_changed)
self.actions.enable_capture.connect(self.enable_capture)
self.actions.reset_logic_analyzer.connect(self.reset_logic_analyzer)
self.actions.repeat_count_changed.connect(self.repeat_count_changed)
self.actions.trigger_offset_changed.connect(self.capture_offset_changed)
self.actions.repeat_count_update.connect(self.update_repeat_count)
self.actions.trigger_offset_update.connect(self.update_capture_offset)
self.actions.restart_logic_analyzer.connect(self.restart_logic_analyzer)
self.actions.capture_detected.connect(self.capture_detected)
def _initialize(self, platform, urn):
self.v = View(self.status, self.actions)
self.v.setup_view()
self.lax = LogicAnalyzer(platform, urn, debug = False)
self.lax.set_both_edge(0x00000000)
self.lax.set_trigger_edge(0xFFFFFFFF)
self.v.update_enable(self.lax.is_enabled())
if self.lax.is_enabled():
self.lax.enable_interrupts(True)
else:
self.lax.enable_interrupts(False)
self.v.update_repeat_count(self.lax.get_repeat_count())
self.v.update_trigger_offset(self.lax.get_trigger_after())
self.v.update_trigger_enable(self.lax.get_trigger_mask())
self.v.update_trigger_polarity(self.lax.get_trigger())
self.lax.register_interrupt_callback(self.actions.capture_detected)
def start_tab_view(self, platform, urn, status):
self.status = status
self.status.Verbose( "Starting Template Application")
self._initialize(platform, urn)
def get_view(self):
return self.v
def capture_detected(self):
print "Capture Detected"
filepath = self.v.get_save_filepath()
data = self.lax.read_data()
clock_count = self.lax.get_clock_divider()
buf = create_vcd_buffer(data, count = 32, clock_count = clock_count, add_clock = True)
f = open(filepath, "w")
f.write(buf)
f.close()
print "Wrote file: %s" % filename
def trigger_enable_changed(self):
value = self.v.get_trigger_enable()
print "Trigger enable value: 0x%08X" % value
self.lax.set_trigger_mask(value)
def trigger_pol_changed(self):
value = self.v.get_trigger_polarity()
print "Trigger polarity value: 0x%08X" % value
self.lax.set_trigger(value)
def enable_capture(self, enable):
if enable:
print "Enable Capture!"
if not self.lax.is_interrupts_enabled():
self.lax.enable_interrupts(True)
else:
print "Disable Capture"
if self.lax.is_interrupts_enabled():
self.lax.enable_interrupts(False)
self.lax.enable(enable)
def reset_logic_analyzer(self):
print "Reset Logic Analyzer"
self.lax.reset()
self.v.update_enable(self.lax.is_enabled())
self.lax.enable_interrupts(False)
self.update_repeat_count()
self.update_capture_offset()
self.update_trigger_polarity()
self.update_trigger_enable()
def restart_logic_analyzer(self):
print "Restart Logic Analyzer"
self.lax.restart()
self.v.update_enable(self.lax.is_enabled())
self.lax.enable_interrupts(False)
self.update_repeat_count()
self.update_capture_offset()
self.update_trigger_polarity()
self.update_trigger_enable()
def repeat_count_changed(self):
count = self.v.get_repeat_count()
print "Repeat Count: %d" % count
self.lax.set_repeat_count(count)
def capture_offset_changed(self):
offset = self.v.get_trigger_offset()
print "Capture offset: %d" % offset
self.lax.set_trigger_after(offset)
def update_trigger_enable(self):
self.v.update_trigger_enable(self.lax.get_trigger_mask())
def update_trigger_polarity(self):
self.v.update_trigger_polarity(self.lax.get_trigger())
def update_repeat_count(self):
print "Update the repeat count"
repeat_count = self.lax.get_repeat_count()
self.v.update_repeat_count(repeat_count)
def update_capture_offset(self):
print "Update capture offset"
trigger_after = self.lax.get_trigger_after()
self.v.update_trigger_offset(trigger_after)
class Controller(NysaBaseController):
@staticmethod
def get_name():
return APP_NAME
@staticmethod
def get_driver():
return DRIVER
def __init__(self):
super (Controller, self).__init__()
self.status = None
self.actions = None
self.memory_actions = MemoryActions()
self.mutex = QMutex()
self.reader_thread = None
self.memory_actions.memory_test_start.connect(self.start_tests)
self.memory_actions.memory_read_finished.connect(self.run_test)
self.memory_actions.memory_file_2_memory.connect(self.file_2_memory)
self.memory_actions.memory_memory_2_file.connect(self.memory_2_file)
def __del__(self):
if self.reader_thread is not None:
self.status.Important( "Waiting for reader thread to finish")
self.reader_thread.join()
def _initialize(self, platform, urn):
self.n = platform
self.urn = urn
self.v = View(self.status, self.memory_actions)
self.v.setup_view()
self.status.Verbose("URN: %s" % urn)
self.v.add_test("Single Read/Write at Start", True, self.test_single_rw_start)
self.v.add_test("Single Read/Write at End", True, self.test_single_rw_end)
self.v.add_test("Long Read/Write Test", True, self.test_long_burst)
self.v.set_memory_size(self.n.get_device_size(urn))
self.v.set_memory_offset(self.n.get_device_address(urn))
self.v.set_nysa(self.n)
self.v.set_urn(self.urn)
def start_tab_view(self, platform, urn, status):
self.status = status
self._initialize(platform, urn)
def get_view(self):
return self.v
def file_2_memory(self, filename, address, count = None):
"""
Data should be in the form of a byte array
"""
f = open(filename, 'rb')
d = Array('B')
d.fromstring(f.read())
f.close()
if count is None:
count = len(d)
mem_base = self.n.get_device_address(self.urn)
print "Writing %d bytes down" % len(d[0:count])
self.n.write_memory(mem_base + address, d[0:count])
def memory_2_file(self, filename, address, byte_count):
f = open(filename, 'wb')
mem_base = self.n.get_device_address(self.urn)
data = self.n.read_memory(mem_base + address, ((byte_count + 3) / 4))
data[0:byte_count].tofile(f)
f.close()
def start_tests(self):
print "Start Tests!"
self.gen = test_iterator(self.v.get_num_tests())
self.run_test()
def get_test(self):
index = self.gen.next()
if self.v.is_test_enabled(index):
return self.v.get_test_function(index)
return None
def run_test(self, status = None):
finished = False
if status is not None:
print "Finished test, Result: %s" % status
try:
while not finished:
t = self.get_test()
if t is not None:
print "Running Test: %s" % str(t)
self.reader_thread = ReaderThread(self.mutex, t)
self.reader_thread.start()
return
else:
continue
except StopIteration:
self.v.update()
print "Done!"
def test_single_rw_start(self):
status = "Passed"
print "device URN: %s" % self.urn
size = self.n.get_device_size(self.urn)
offset = self.n.get_device_address(self.urn)
print "size: 0x%08X" % size
print "offset: 0x%08X" % offset
self.clear_memory()
if self.status.is_command_line():
self.status.Verbose( "Test Single Read/Write at Beginning")
data_out = Array('B', [0xAA, 0xBB, 0xCC, 0xDD, 0x55, 0x66, 0x77, 0x88])
self.n.write_memory(offset, data_out)
print "Wrote second part!"
data_in = self.n.read_memory(offset, len(data_out)/4)
print "length: data_out: %d, data_in: %d" % (len(data_out), len(data_in))
print "data out: %s" % str(data_out)
print "data_in: %s" % str(data_in)
for i in range (len(data_out)):
if data_in[i] != data_out[i]:
status = "Failed"
print "Error at: 0x%02X OUT: 0x%08X IN: 0x%08X" % (i, data_out[i], data_in[i])
#print "ERROR at: [{0:>2}] OUT: {1:>8} IN: {2:>8}".format(str(i), hex(data_out[i]), hex(data_in[i]))
return status
def test_single_rw_end(self):
status = "Passed"
size = self.n.get_device_size(self.urn)
offset = self.n.get_device_address(self.urn)
self.clear_memory()
if self.status.is_command_line():
self.status.Verbose( "Test Single Read/Write at End")
data_out = Array('B', [0xAA, 0xBB, 0xCC, 0xDD, 0x55, 0x66, 0x77, 0x88])
self.n.write_memory(offset + (size - 16), data_out)
print "Reading from location: 0x%08X" % (offset + (size - 16))
data_in = self.n.read_memory(offset + (size - 16), 2)
for i in range (len(data_out)):
if data_in[i] != data_out[i]:
print "Error at: 0x%02X OUT: 0x%08X IN: 0x%08X" % (i, data_out[i], data_in[i])
#print "ERROR at: [{0:>2}] OUT: {1:>8} IN: {2:>8}".format(str(i), hex(data_out[i]), hex(data_in[i]))
status = "Failed"
return status
def test_long_burst(self):
status = "Passed"
fail = False
fail_count = 0
position = 0
self.clear_memory()
total_size = self.n.get_device_size(self.urn)
offset = self.n.get_device_address(self.urn)
size = 0
if total_size > MAX_LONG_SIZE:
self.status.Info("Memory Size: 0x%08X is larger than read/write size" % total_size)
self.status.Info("\tBreaking transaction into 0x%08X chunks" % MAX_LONG_SIZE)
size = MAX_LONG_SIZE
else:
size = total_size
#Generate Data to Write
data_out = Array('B')
for i in range (0, size * 4):
data_out.append((i % 256))
print "Length of data: 0x%08X" % len(data_out)
print "32-bit Length: 0x%08X" % (len(data_out) / 2)
#Write Data Out
while position < total_size:
start = time.time()
self.n.write_memory(offset + position, data_out)
end = time.time()
#Increment the position
prev_pos = position
position += size
if position + size > total_size:
size = total_size - position
self.status.Info("Wrote: 0x%08X - 0x%08X" % (prev_pos, position))
self.status.Verbose( "Write Time : %f" % (end - start))
position = 0
start = time.time()
if total_size > MAX_LONG_SIZE:
self.status.Info("Memory Size: 0x%08X is larger than read/write size" % total_size)
self.status.Info("\tBreaking transaction into 0x%08X chunks" % MAX_LONG_SIZE)
size = MAX_LONG_SIZE
else:
size = total_size
while position < total_size:
data_in = self.n.read_memory(offset + position, len(data_out) / 4)
end = time.time()
self.status.Verbose( "Read Time: %f" % (end - start))
self.status.Verbose( "Comparing Values...")
if len(data_out) != len(data_in):
if self.status.is_command_line():
self.status.Error( "Data in length not equal to data_out length")
self.status.Error( "\toutgoing: %d" % len(data_out))
self.status.Error( "\tincomming: %d" % len(data_in))
dout = data_out.tolist()
din = data_in.tolist()
for i in range(len(data_out)):
out_val = dout[i]
in_val = din[i]
if out_val != in_val:
fail = True
status = "Failed"
self.status.Error("Mismatch @ 0x%08X: %d and %d not equal" % (position + i, out_val, in_val))
self.status.Error("Mismatch @ 0x%08X: Write: (Hex): 0x%08X Read (Hex): 0x%08X" % (i, data_out[i], data_in[i]))
if fail_count >= 16:
break
fail_count += 1
prev_pos = position
position += size
prev_size = size
if position + size > total_size:
size = total_size - position
self.status.Info("Read: 0x%08X - 0x%08X Size: 0x%08X" % (prev_pos, position, prev_size))
return status
def clear_memory(self):
total_size = self.n.get_device_size(self.urn)
offset = self.n.get_device_address(self.urn)
position = 0
size = 0
if self.status.is_command_line():
self.status.Verbose( "Clearing Memory")
self.status.Verbose( "Memory Size: 0x%08X" % size)
if total_size > MAX_LONG_SIZE:
self.status.Info("Memory Size: 0x%08X is larger than read/write size" % total_size)
self.status.Info("\tBreaking transaction into 0x%08X chunks" % MAX_LONG_SIZE)
size = MAX_LONG_SIZE
else:
size = total_size
while position < total_size:
data_out = Array('B')
for i in range(0, ((size / 4) - 1)):
num = 0x00
data_out.append(num)
self.n.write_memory(offset + position, data_out)
#Increment the position
prev_pos = position
position += size
if position + size > total_size:
size = total_size - position
if self.status:
self.status.Verbose("Cleared: 0x%08X - 0x%08X" % (prev_pos, position))
