def test_channel_playback(self):
class config: pass
cfg = config()
cfg.chs = [1]
cfg.nullAlgoLatency = 4
cfg.playStart = orb.Point(0)
cfg.playStop = orb.Point(2)
cfg.playPayload = 'generate://pattern'
cfg.capStart = orb.Point(0, cfg.nullAlgoLatency)
cfg.capStop = orb.Point(2, cfg.nullAlgoLatency)
cfg.capPath = None
m = self.board.getMetric()
d = m.distance(cfg.playStop, cfg.playStart)
# RX buffer in pattern mode
datapath.XBuffers.run(self.board, 'rx', 'PlayOnce', cfg.chs, cfg.playPayload, (cfg.playStart,cfg.playStop))
# Tx buffers in capture mode
datapath.XBuffers.run(self.board, 'tx', 'Capture', cfg.chs, None, (cfg.capStart, cfg.capStop))
# Capture!
rx,tx = datapath.Capture.run(self.board, cfg.chs, cfg.chs, cfg.capPath)
# Compare captures in the relevant range
errors = compareBufferData(rx,tx, (0,d) )
tools.assert_equal(len(errors),0)
def test_pattern_packet(self):
cfg = mp7nose.TestConfig()
cfg.chs = [1,2]
cfg.pattStart = orb.Point(2)
cfg.pattStop = orb.Point(5)
cfg.capStart = orb.Point(1)
cfg.capStop = None
cfg.capPath = None
cfg.nullAlgoLatency = 4
rx,tx = self.pattern_and_capture(cfg)
# Break down the daptured data in packets
packets = data.findAllPackets(tx)
# When channels are aligned, there is only one train of packets
tools.assert_equal(len(packets),1,'Expected 1 packet train in capture, found %d' % len(packets))
# first and only packet, unpack
pkts, chans = packets[0]
tools.assert_equal(chans, cfg.chs)
# extract the first packet
firstPkt = pkts[0]
m = self.board.getMetric()
errors = checkCapturedPattern(tx, firstPkt, chans, cfg.capStart, cfg.nullAlgoLatency, m)
tools.assert_equal(len(errors),0, 'Capture errors detected\n'+'\n'.join(errors))
def test_pattern_full(self):
cfg = mp7nose.TestConfig()
cfg.chs = [1,2]
cfg.nullAlgoLatency = 4
cfg.pattStart = orb.Point(0)
cfg.pattStop = None
cfg.capStart = orb.Point(1,cfg.nullAlgoLatency)
cfg.capStop = None
cfg.capPath = 'nosecap'
rx,tx = self.pattern_and_capture(cfg)
def test_pattern_latency(self):
'''
Checks the rx to rx buffers latency.
A short packer is sent from rx buffers to tx buffers.
The latency is measured by capturing the packet at tx buffers and
comparing the rising edge of data-valid with the time of transmission.
* Rx buffers configured to produce the hardcoded pattern.
* TX buffers in capture mode.
'''
cfg = mp7nose.TestConfig()
cfg.chs = [1,2]
cfg.pattStart = orb.Point(2)
cfg.pattStop = orb.Point(5)
cfg.capStart = orb.Point(1)
cfg.capStop = None
cfg.capPath = None
cfg.nullAlgoLatency = 4
rx,tx = self.pattern_and_capture(cfg)
# Analyze capture
# Break down the daptured data in packets
packets = data.findAllPackets(tx)
# When channels are aligned, there is only one train of packets
tools.assert_equal(len(packets),1,'Expected 1 packet train in capture, found %d' % len(packets))
# first and only packet, unpack
pkts, chans = packets[0]
# extract the first packet
firstPkt = pkts[0]
m = self.board.getMetric()
# Measure the latency based on data valid
algoLatency = measureDatavalidLatency( firstPkt[0], cfg.capStart, cfg.pattStart, m )
tools.assert_equal(algoLatency, cfg.nullAlgoLatency)
def setup_class(cls):
'''Configure class for tests. Configure the board and capture.
Store the event and the configuration locally
'''
# Take a snapshot of this module's config
#config = copy.deepcopy(defaults)
config = defaults
print "%s - loading menu '%s' from %s" % (cls.__name__, cls.menuName,
cls.menuFile)
# Preparing test
cls.board = cls.context().mp7
print 'Resetting board'
infra.Reset.run(cls.board, **config['reset'])
print 'Configure Tx to send patterns'
datapath.XBuffers.run(cls.board, 'rx', 'Zeroes', None, None,
(orbit.Point(0), None))
datapath.XBuffers.run(cls.board, 'tx', 'Zeroes', None, None,
(orbit.Point(0), None))
datapath.XBuffers.run(cls.board, 'rx', 'Pattern', cls.patternchans,
None, (orbit.Point(0), None))
print 'Configuing latency buffers'
readout.EasyLatency.run(cls.board, **config['easylatency'])
print 'Setting up readout'
readout.Setup.run(cls.board, **config['setup'])
print 'Configuring out menu'
readout.LoadMenu.run(cls.board, cls.menuFile, cls.menuName)
# Additionally, set board id
ctrl = cls.board.getCtrl()
ctrl.getNode('board_id').write(0x1234)
ctrl.getClient().dispatch()
result = readout.CaptureEvents.run(cls.board, **config['capture'])
# Stop if the capture was bugged
tools.assert_not_equal(
result, None,
"There's no event in here. Is the FIFO empty? Maybe you didn't set up correctly."
)
# Append result to the class
cls.result = result
def test_cap_greater_than_pattern(self):
class config(): pass
cfg = config()
# Use one channel only
cfg.chs = [3]
# 1 BX long data valid
cfg.pattStart = orb.Point(1,0)
cfg.pattStop = orb.Point(2,0)
# Capture for 3 Bxs, starting at 1
cfg.capStart = orb.Point(1,0)
cfg.capStop = orb.Point(4,0)
# TX in pattern mode
datapath.XBuffers.run(self.board, 'rx', 'Pattern', cfg.chs, None, (cfg.pattStart,cfg.pattStop))
# RX in capture mode
datapath.XBuffers.run(self.board, 'tx', 'Capture', cfg.chs, None, (cfg.capStart, cfg.capStop))
# Capture
rx, tx = datapath.Capture.run(self.board, cfg.chs, cfg.chs)
# Break down the daptured data in packets
pktTrains = data.findAllPackets(tx)
tools.assert_equal(len(pktTrains),1,'Expected 1 packet train in capture, found %d' % len(pktTrains))
pktTrain, chans = pktTrains[0]
tools.assert_equal(len(pktTrain),1,'Expected 1 packet, found %d - %s' % (len(pktTrain),pktTrain))
first,last = pktTrain[0]
pktLen = last-first+1
# cnt = self.countValidFrames(tx)
print 'Packet length: ',pktLen
m = self.board.getMetric()
# Compare measured datavalid with expectations
# Pattern range is shorter than capture's. The packet length is expected to match the pattern range.
tools.assert_equal(pktLen, m.distance(cfg.pattStop, cfg.pattStart) )
def measureDatavalidLatency( vStart, capStart, pattStart, metric ):
'''Measures latency between playback/pattern and capture based on data valid position'''
vP = orb.Point(
vStart/metric.clockRatio(),
vStart%metric.clockRatio()
)
p0Tx = metric.add(vP,capStart)
algoLatency = metric.distance(p0Tx,pattStart)
return algoLatency
ncap = info['mask_ram_depth'] / 6
print 'Supported capture modes: 0', ncap - 1
zs.enable()
menuFile = "${MP7_TESTS}/python/daq/simple.py"
menuName = "menuA"
zsMenuName = "zsMenuA"
# print 'Resetting board'
# infra.Reset.run(board, **config['reset'])
print 'Configure Rx to send patterns'
# datapath.XBuffers.run(board, 'rx', 'PlayOnce', [0,1,2,3], 'generate://pattern',(orbit.Point(0),None))
datapath.XBuffers.run(board, 'rx', 'Pattern', [0, 1, 2, 3], None,
(orbit.Point(0), None))
print 'Configuing latency buffers'
readout.EasyLatency.run(board, **config['easylatency'])
print 'Setting up readout'
readout.Setup.run(board, **config['setup'])
print 'Configuring readout menu'
readout.LoadMenu.run(board, menuFile, menuName)
print 'Configuring zs menu'
readout.LoadZSMenu.run(board, menuFile, zsMenuName)
# Additionally, set board id
ctrl = board.getCtrl()
ctrl.getNode('board_id').write(0x1234)
ctrl.getClient().dispatch()
result = readout.CaptureEvents.run(board, **config['capture'])