def test_parse_chip_key():
chip_id = 62
io_chain = 0
expected = {'chip_id': chip_id, 'io_chain': io_chain}
key = '{}-{}'.format(io_chain, chip_id)
assert ZMQ_IO.is_valid_chip_key(key)
assert ZMQ_IO.parse_chip_key(key) == expected
def test_running_with_bern_daq():
from larpix.larpix import Controller
from larpix.io.zmq_io import ZMQ_IO
controller = Controller()
controller.io = ZMQ_IO(config_filepath='io/loopback.json')
controller.load('controller/pcb-2_chip_info.json')
for key, chip in controller.chips.items():
chip.config.load('chip/quiet.json')
print(key, chip.config)
def quickcontroller(board='pcb-5',
interactive=False,
io=None,
logger=None,
log_filepath=None):
'''Quick jump through all controller creation and config steps'''
controller_config = 'controller/{}_chip_info.json'.format(board)
if io is None:
io_config = 'io/daq-srv1.json'
io = ZMQ_IO(io_config)
if logger is None:
logger = HDF5Logger(filename=log_filepath)
logger.open()
controller = larpix.Controller()
controller.io = io
controller.logger = logger
controller.load(controller_config)
silence_chips(controller, interactive)
set_config_physics(controller, interactive)
return controller
def quickcontroller(board='pcb-1',
interactive=False,
io=None,
logger=None,
log_filepath=None):
'''Quick jump through all controller creation and config steps'''
if io is None:
io = ZMQ_IO('tcp://10.0.1.6')
# io = SerialPort(baudrate=1000000,
# timeout=0.01)
enable_logger()
cont = create_controller(io=io)
if logger is None:
cont.logger = HDF5Logger(filename=log_filepath)
cont.logger.open()
init_controller(cont, board)
silence_chips(cont, interactive)
if cont.board_info['name'] == 'unknown':
# Find and load chip info
settings = {'controller': cont}
cont.chips = get_chip_ids(**settings)
set_config_physics(cont, interactive)
#flush_stale_data(cont)
return cont
def zmq_io_obj(io_config):
return ZMQ_IO(io_config)
from configure_to_rate import _configure_to_rate
from larpix.larpix import *
from larpix.io.zmq_io import ZMQ_IO
from larpix.logger.h5_logger import HDF5Logger
c = Controller()
c.io = ZMQ_IO('../configs/io/daq-srv1.json', miso_map={2: 1})
c.load('../configs/controller/pcb-3_chip_info.json')
c.io.ping()
for key, chip in c.chips.items():
chip.config.load('../configs/chip/quiet.json')
c.write_configuration(key)
if not c.verify_configuration():
print("verify configuration failed!")
exit()
c.disable()
chip_key = '1-1-10'
c.chips[chip_key].config.global_threshold = 24
c.write_configuration(chip_key)
if not c.verify_configuration():
print("verify configuration failed!")
exit()
c.enable(chip_key, [5])
c.chips[chip_key].config.sample_cycles = 255
#c.enable_analog_monitor(chip_key, 26)
c.enable_testpulse(chip_key, [5], start_dac=200)
c.write_configuration(chip_key)
def test_decode():
test_bytes = b'\x00\x06\x05\x04\x03\x02\x01\x00'
expected = [Packet(test_bytes[:-1])]
assert ZMQ_IO.decode([test_bytes]) == expected
def test_encode():
test_bytes = b'\x00\x01\x02\x03\x04\x05\x06'
expected = [b'0x0006050403020100 0']
assert ZMQ_IO.encode([Packet(test_bytes)]) == expected
def test_generate_chip_key():
chip_id = 125
io_chain = 2
expected = '{}-{}'.format(io_chain, chip_id)
assert ZMQ_IO.is_valid_chip_key(expected)
assert ZMQ_IO.generate_chip_key(chip_id=chip_id, io_chain=io_chain)