timing.cli.hsi Namespace Reference

Functions
	hsi (obj, device)
	status (ctx, obj)
	enable (ctx, obj, action, partition, address)
	configure (ctx, obj, src, re_mask, fe_mask, inv_mask, rate)
	readback (ctx, obj)
	read (ctx, obj, readall, continuous, print_out, read_period, save, file_name)

Function Documentation

configure()

timing.cli.hsi.configure	(		ctx,
			obj,
			src,
			re_mask,
			fe_mask,
			inv_mask,
			rate )

Configure the hsi in the hsi wrapper block.

Definition at line 114 of file hsi.py.

def configure(ctx, obj, src, re_mask, fe_mask, inv_mask, rate):
    '''
    Configure the hsi in the hsi wrapper block.
    '''
 
    lDevice = obj.mDevice
    lHSI = obj.mHSI
    lTopDesign = obj.mTopDesign
 
    lHSI.reset_hsi()
    lTopDesign.configure_hsi(src, re_mask, fe_mask, inv_mask, rate)
 
    secho("HSI configured", fg='green')
 
    time.sleep(0.1)
    ctx.invoke(status)
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@hsi.command('start', short_help='Start the hsi triggering and the writing events into buffer.')
@click.pass_obj
@click.pass_context

enable()

timing.cli.hsi.enable	(		ctx,
			obj,
			action,
			partition,
			address )

Activate the timing endpoint in the hsi design. Left in for compatibility reasons

Definition at line 84 of file hsi.py.

def enable(ctx, obj, action, partition, address):
    '''
    Activate the timing endpoint in the hsi design. Left in for compatibility reasons
    '''
 
    lDevice = obj.mDevice
    lEndpoint = obj.mEndpoint
    lHSI = obj.mHSI
    
    if action == 'off':
        lEndpoint.disable()
    elif action == 'on':
        lEndpoint.enable(address=address,partition=partition)
    elif action == 'reset':
        lEndpoint.reset(address=address,partition=partition)
        lHSI.reset_hsi()
 
    time.sleep(0.1)
    ctx.invoke(status)
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@hsi.command('configure', short_help="Configure the HSI block for running")
@click.pass_obj
@click.pass_context
@click.option('--src', '-s', type=click.IntRange(0x0,0x1), help='Source of HSI data,; 0: hardware; 1: timestamp (emulation mode)', default=0)
@click.option('--re-mask', '-r', type=click.IntRange(0,0xffffffff), help='Rising edge mask', default=0)
@click.option('--fe-mask', '-f', type=click.IntRange(0,0xffffffff), help='Falling edge mask', default=0)
@click.option('--inv-mask', '-i', type=click.IntRange(0,0xffffffff), help='Invert mask', default=0)
@click.option('--rate', type=float, help='Random trigger rate [Hz] on bit 0 in emulation mode', default=1)

hsi()

timing.cli.hsi.hsi	(		obj,
			device )

HSI commands.

\b
DEVICE: uhal device identifier
IDS: id(s) of the target endpoint(s).

Definition at line 25 of file hsi.py.

def hsi(obj, device):
    '''
    HSI commands.
 
    \b
    DEVICE: uhal device identifier
    IDS: id(s) of the target endpoint(s).
    '''
 
    lDevice = obj.mConnectionManager.getDevice(str(device))
    if obj.mTimeout:
        lDevice.setTimeoutPeriod(obj.mTimeout)
 
    
    echo('Created HSI device')
    lTopDesign = lDevice.getNode('')
    lBoardInfo = toolbox.readSubNodes(lDevice.getNode('io.config'), False)
    lDevice.dispatch()
 
    if lBoardInfo['board_type'].value() in kLibrarySupportedBoards and lBoardInfo['design_type'].value() in kLibrarySupportedDesigns:
        lTopDesign.validate_firmware_version()
        try:
            echo(lDevice.getNode('io').get_hardware_info())
        except:
            secho("Failed to retrieve hardware information! I2C issue? Initial board reset needed?", fg='yellow')
            e = sys.exc_info()[0]
            secho("Error: {}".format(e), fg='red')
 
    obj.mDevice = lDevice
    obj.mEndpoint = lDevice.getNode('endpoint0')
    obj.mTopDesign = lDevice.getNode('')
    obj.mHSI = obj.mTopDesign.get_hsi_node()
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@hsi.command('status')
@click.pass_obj
@click.pass_context

read()

timing.cli.hsi.read	(		ctx,
			obj,
			readall,
			continuous,
			print_out,
			read_period,
			save,
			file_name )

Read the content of the endpoint master readout buffer.

Definition at line 179 of file hsi.py.

def read(ctx, obj, readall, continuous, print_out, read_period, save, file_name):
    '''
    Read the content of the endpoint master readout buffer.
    '''
    lDevice = obj.mDevice
    lHSI = obj.mHSI
    
    read_events=0
    if continuous:
        secho("[INFO] Starting HSI data readout", fg='green')
        if not (save or print_out):
            secho('[WARNING] you have chosen to neither save or print the HSI data', fg='yellow')
        last_ts=0
        if save:
            h5_file_name = datetime.now().strftime("hsi_data_%d_%m_%Y_%H_%M_%S.hdf5")
            if file_name is not None:
                h5_file_name=file_name
 
            f = h5py.File(h5_file_name, "w")
            hsi_dataset = f.create_dataset("hsi_frames", (0,7), maxshape=(None, 7), chunks=True, dtype='u4')
        else:
            if file_name is not None:
                secho('[WARNING] You have provided a file name but chosen not to save the readout data', fg='yellow')
 
        with toolbox.InterruptHandler() as h:
            while(True):
                n_words=0
                hsi_words = lHSI.read_data_buffer(n_words,False,False)
                n_hsi_events = len(hsi_words) // kHSIWordsNumber
 
                if save:
                    hsi_dataset_start_index=hsi_dataset.shape[0]
                    hsi_dataset.resize(hsi_dataset_start_index+n_hsi_events, axis=0)
 
                if (len(hsi_words) % kHSIWordsNumber == 0 and hsi_words.size() > 0):
 
                    for i in range(0,n_hsi_events):
                        start_index = i * kHSIWordsNumber
                        end_index = start_index + kHSIWordsNumber
                        raw_event=hsi_words[start_index:end_index]
 
                        header = raw_event[0]
                        ts_low = raw_event[1]
                        ts_high = raw_event[2]
                        data = raw_event[3]
                        trigger = raw_event[4]
 
                        ts = ts_low | (ts_high << 32)
 
                        # bits 15-0 contain the sequence counter
                        counter = header & 0x0000ffff
 
                        if (header >> 16) != 0xaa00:
                            secho("[ERROR] Invalid HSIEventHeader", fg='red')
                            continue
 
                        if ts == 0:
                            secho("[ERROR] Invalid HSIEvent timestamp", fg='red')
                            continue
 
                        delta_ticks=ts-last_ts
                        if last_ts == 0:
                            delta_ticks=0
                        last_ts=ts
 
                        if print_out:
                            print(f"[INFO] got event: {counter} ts: {ts} signals: {data} delta ts: {delta_ticks}")
 
                        read_events=read_events+1
                        if save:
                            hsi_dataset[hsi_dataset_start_index+i,0]=(0x1 << 6) | 0x1 # DAQHeader, frame version: 1, det id: 1
                            hsi_dataset[hsi_dataset_start_index+i,1]=ts_low
                            hsi_dataset[hsi_dataset_start_index+i,2]=ts_high
                            hsi_dataset[hsi_dataset_start_index+i,3]=data
                            hsi_dataset[hsi_dataset_start_index+i,4]=0x0
                            hsi_dataset[hsi_dataset_start_index+i,5]=trigger
                            hsi_dataset[hsi_dataset_start_index+i,6]=counter
 
                elif len(hsi_words) != 0:
                    secho(f"[ERROR] unexpected n words {len(hsi_words)}", fg='red')
                if h.interrupted:
                    secho(f"[INFO] Stopping HSI data readout after {read_events} events", fg='green')
                    break
                time.sleep(read_period*1e-3)
        if save:
            f.close()
    else:
        echo(lHSI.get_data_buffer_table(readall,False))
# ------------------------------------------------------------------------------

readback()

timing.cli.hsi.readback	(		ctx,
			obj )

Read the content of the endpoint master readout buffer.

Definition at line 137 of file hsi.py.

def readback(ctx, obj):
    '''
    Read the content of the endpoint master readout buffer.
    '''
    lDevice = obj.mDevice
    lHSI = obj.mHSI
 
    lHSI.start_hsi()
    secho("HSI start", fg='green')
 
    time.sleep(0.1)
    ctx.invoke(status)
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@hsi.command('stop', short_help='Stop the hsi triggering and the writing events into buffer.')
@click.pass_obj
@click.pass_context

status()

timing.cli.hsi.status	(		ctx,
			obj )

Print the status of CRT endpoint wrapper block.

Definition at line 64 of file hsi.py.

def status(ctx, obj):
    '''
    Print the status of CRT endpoint wrapper block.
    '''
 
    lDevice = obj.mDevice
    lHSI = obj.mHSI
    lEndpoint = obj.mEndpoint
    
    echo(lEndpoint.get_status())
    echo(lHSI.get_status())
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@hsi.command('enable', short_help="Configure the HSI endpoint for running")
@click.pass_obj
@click.pass_context
@click.argument('action', default='on', type=click.Choice(['on', 'off', 'reset']))
@click.option('--partition', '-p', type=click.IntRange(0,4), help='Partition', default=0)
@click.option('--address', '-a', type=toolbox.IntRange(0x0,0x100), help='Address', default=0)