# Load network configuration
ctl.load('controller/testing_network.json')
for io_group in ctl.network:
for io_channel in ctl.network[io_group]:
chip_keys = ctl.get_network_keys(io_group, io_channel)
for chip_key in chip_keys:
# Initialize network node
chip_id = chip_key.chip_id
ctl.init_network(io_group, io_channel, chip_id) # assume upstream nodes of chip key are configured and configure specified chip
ok, diff = ctl.verify_network(chip_key)
if not ok:
raise RuntimeError
ctl[chip_key].config.load('chip/testing_base.json') # load base configuration (don't specify chip_id, mosi, miso_*)
ctl.write_configuration(chip_key)
ok, diff = ctl.verify_configuration(chip_key)
if not ok:
raise RuntimeError
# Chip level tests
ctl[chip_key].config.global_threshold = 30
ctl.write_configuration(chip_key, chip_key.config.register_map['global_threshold'])
# etc
test_channel = 4
ctl.enable_analog_monitor(chip_key, test_channel)
# etc
# Full system tests
from larpix import Controller
from larpix.io import PACMAN_IO
ctl = Controller()
# Bring up communications with io groups
ctl.io = PACMAN_IO('io/production_io.json') # specifies ip addresses + etc for io groups
if not ctl.io.ping():
raise RuntimeError
# Bring up Hydra networks
ctl.load('controller/production_hydra_networks.json') # specifies hydra network on each io channel / group
for io_group in ctl.network:
for io_channel in ctl.network[io_group]:
ctl.init_network(io_group, io_channel) # loads network configurations
valid, configs = ctl.verify_network() # performs read back of each chip's miso/mosi config
if not valid:
raise RuntimeError
# Enable channels and set thresholds
for chip_key, chip in ctl.chips.items():
chip.config.load('chip/{}.json'.format(chip_key)) # loads chip specific configurations
for chip_key, chip in ctl.chips.items():
ctl.write_configuration(chip_key) # writes chip specific configurations
valid, configs = ctl.verify_configuration() # performs read back of each chip's full configuration
if not valid:
raise RuntimeError
# RUN!
from larpix import Controller
from larpix.io import PACMAN_IO
ctl = Controller()
# Bring up communications with io group
ctl.io = PACMAN_IO(
'io/manual_io.json') # specifies ip addresses + etc for io group
ctl.io.ping()
# Load network configuration
ctl.load('controller/testing_network.json')
# Fiddle with root chip
ctl.init_network(1, 1, 2)
ctl.verify_network('1-1-2')
ctl['1-1-2'].config.load('chip/manual_base.json')
ctl.write_configuration('1-1-2')
ctl.verify_configuration('1-1-2')
# do stuff
# Fiddle with next chip
ctl.init_network(1, 1, 3)
ctl.verify_network('1-1-3')
ctl['1-1-3'].config.load('chip/manual_base.json')
ctl.write_configuration('1-1-3')
ctl.verify_configuration('1-1-3')
# ...
def test_tutorial(capsys, tmpdir, temp_logfilename):
from larpix import Controller, Packet_v2
from larpix.io import FakeIO
from larpix.logger import StdoutLogger
controller = Controller()
controller.io = FakeIO()
controller.logger = StdoutLogger(buffer_length=0)
controller.logger.enable()
chipid = 5
chip_key = '1-1-5'
chip5 = controller.add_chip(chip_key, version=2)
chip5 = controller[chip_key]
chip5 = controller[1, 1, 5]
from larpix import Key
example_key = Key(1, 2, 3)
assert example_key.io_group == 1
assert example_key.io_channel == 2
assert example_key.chip_id == 3
example_key.to_dict()
controller.load('controller/v2_example.json')
print(controller.chips) # chips that have been loaded into controller
list(controller.network[1][1]
['miso_ds'].edges) # all links contained in the miso_ds graph
list(controller.network[1][1]
['miso_us'].nodes) # all nodes within the miso_us graph
list(controller.network[1][1]
['mosi'].edges) # all links within the mosi graph
list(controller.network[1][1]['mosi'].in_edges(
2)) # all links pointing to chip 2 in mosi graph
list(controller.network[1][1]['miso_ds'].successors(
3)) # all chips receiving downstream data packets from chip 3
controller.network[1][1]['mosi'].edges[(
3, 2
)]['uart'] # check the physical uart channel that chip 2 listens to chip 3 via
controller.network[1][1]['mosi'].nodes[2][
'root'] # check if designated root chip
controller.init_network(
1, 1) # issues packets required to initialize the 1,1 hydra network
print(controller['1-1-2'].config.chip_id)
print(controller['1-1-3'].config.enable_miso_downstream)
controller.reset_network(1, 1)
controller.init_network(1, 1, 2) # configures only chip 2
controller.init_network(1, 1, 3) # configures only chip 3
assert isinstance(
controller.get_network_keys(1, 1), list
) # gets a list of chip keys starting at the root node and descending
assert isinstance(
controller.get_network_keys(1, 1, root_first_traversal=False),
list) # get list of chip keys starting at deepest chips and ascending
chip5.config.threshold_global = 35 # entire register = 1 number
chip5.config.enable_periodic_reset = 1 # one bit as part of a register
chip5.config.channel_mask[20] = 1 # one bit per channel
controller.write_configuration(chip_key) # send all registers
controller.write_configuration(chip_key, 32) # send only register 32
controller.write_configuration(chip_key,
[32, 50]) # send registers 32 and 50
threshold_global_reg = chip5.config.register_map['threshold_global']
threshold_global_name = chip5.config.register_map_inv[64]
packets = chip5.get_configuration_read_packets()
bytestream = b'bytes for the config read packets'
controller.io.queue.append((packets, bytestream))
controller.read_configuration(chip_key)
packets = [Packet_v2()] * 40
bytestream = b'bytes from the first set of packets'
controller.io.queue.append((packets, bytestream))
packets2 = [Packet_v2()] * 30
bytestream2 = b'bytes from the second set of packets'
controller.io.queue.append((packets2, bytestream2))
controller.start_listening()
# Data arrives...
packets, bytestream = controller.read()
# More data arrives...
packets2, bytestream2 = controller.read()
controller.stop_listening()
message = 'First data arrived!'
message2 = 'More data arrived!'
controller.store_packets(packets, bytestream, message)
controller.store_packets(packets, bytestream2, message2)
packets = [Packet_v2()] * 5
bytestream = b'[bytes from read #%d] '
for i in range(100):
controller.io.queue.append((packets, bytestream % i))
duration = 0.1 # seconds
message = '10-second data run'
controller.run(duration, message)
run1 = controller.reads[0]
first_packet = run1[0] # Packet object
first_ten_packets = run1[0:10] # smaller PacketCollection object
first_packet_bits = run1[0,
'bits'] # string representation of bits in packet
first_ten_packet_bits = run1[0:10, 'bits'] # list of strings
print(run1) # prints the contents of the packets
print(run1[10:30]) # prints 20 packets from the middle of the run
packet = run1[0]
# all packets
packet.packet_type # unique in that it gives the bits representation
packet.chip_id # all other properties return Python numbers
packet.chip_key # key for association to a unique chip (can be None)
packet.parity
packet.downstream_marker
# data packets
packet.channel_id
packet.dataword
packet.timestamp
packet.trigger_type
packet.local_fifo
packet.shared_fifo
# config packets
packet.register_address
packet.register_data
# if fifo_diagnostics enabled on a given chip the timestamp of data packets
# are interpreted differently (note that this is not done automatically and will
# need to be performed manually on each packet)
packet.fifo_diagnostics_enabled = True
packet.timestamp
packet.local_fifo_events
packet.shared_fifo_events
from larpix.logger import HDF5Logger
controller.logger = HDF5Logger(
filename=temp_logfilename, directory=str(tmpdir), buffer_length=10000
) # a filename of None uses the default filename formatting
controller.logger.enable(
) # opens hdf5 file and starts tracking all communications
controller.logger = HDF5Logger(filename=temp_logfilename,
directory=str(tmpdir),
enabled=True)
controller.verify_configuration()
controller.logger.flush()
controller.logger.disable() # stop tracking
# any communication here is ignored
controller.logger.enable() # start tracking again
controller.logger.is_enabled() # returns True if tracking
controller.logger.disable()
import h5py
datafile = h5py.File(tmpdir.join(temp_logfilename))
assert '_header' in datafile.keys()
assert 'packets' in datafile.keys()
assert 'messages' in datafile.keys()
assert list(
datafile['_header'].attrs) == ['created', 'modified', 'version']
raw_value = datafile['packets'][
0] # e.g. (b'0-246', 3, 246, 1, 1, -1, -1, -1, -1, -1, -1, 0, 0)
raw_values = datafile['packets'][-100:] # last 100 packets in file
packet_repr = raw_values[0:1]
packet_repr['chip_id'] # chip id for packet, e.g. 246
packet_repr['dataword'] # list of ADC values for each packet
packet_repr.dtype # description of data type (with names of each column)
# all packets' ADC counts, including non-data packets
raw_values['dataword']
# Select based on data type using a numpy bool / "mask" array:
raw_values['dataword'][raw_values['packet_type'] ==
0] # all data packets' ADC counts
datafile.close()