timing.cli.debug Namespace Reference

Functions
	debug (obj, device)
	inspect (obj, nodes)
	ipy (ctx)
	uuid (obj)
	sfpexpander (obj)
	sfp_status (obj)
	fanout_sfpscan (obj)
	readSFPStatus (aEEProm, aDiag, aLabel)

Function Documentation

debug()

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

Timing master commands.

DEVICE: uhal device identifier

Definition at line 28 of file debug.py.

def debug(obj, device):
    '''
    Timing master commands.
 
    DEVICE: uhal device identifier
    '''
    lDevice = obj.mConnectionManager.getDevice(str(device))
    if obj.mTimeout:
        lDevice.setTimeoutPeriod(obj.mTimeout)
        
    echo('Created device ' + click.style(lDevice.id(), fg='blue'))
 
    lBoardInfo = toolbox.readSubNodes(lDevice.getNode('io.config'), False)
    lDevice.dispatch()
 
    # print({ k:v.value() for k,v in lBoardInfo.items()})
    # raise SystemExit(0)
 
    echo("Design '{}' on board '{}' on carrier '{}'".format(
        style(kDesignNameMap[lBoardInfo['design_type'].value()], fg='blue'),
        style(kBoardNameMap[lBoardInfo['board_type'].value()], fg='blue'),
        style(kCarrierNameMap[lBoardInfo['carrier_type'].value()], fg='blue')
    ))
 
    obj.mDevice = lDevice
    obj.mBoardType = lBoardInfo['board_type'].value()
    obj.mCarrierType = lBoardInfo['carrier_type'].value()
    obj.mDesignType = lBoardInfo['design_type'].value()
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('inspect')
@click.argument('nodes')
@click.pass_obj

fanout_sfpscan()

timing.cli.debug.fanout_sfpscan

(

obj

)

Definition at line 205 of file debug.py.

def fanout_sfpscan(obj):
    
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType != kBoardPC059:
        print('Wrong board', lBoardType, 'sorry mate')
        return
 
 
    lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x1)
    lDevice.dispatch()
    lDevice.getNode('io.csr.ctrl.rst_i2cmux').write(0x0)
    lDevice.dispatch()
    time.sleep(1)
 
    lSFPNodeName = 'io.i2c'
    lI2CBusNode = lDevice.getNode(lSFPNodeName)
    lSwitchSlave = lI2CBusNode.get_slave('SFP_Switch')
    print(lSwitchSlave.ping())
 
    # print(lSwitchSlave.read_i2cPrimitive(1))
    # time.sleep(0.1)
 
    lSwitchSlave.write_i2cPrimitive([3])
    print(lSwitchSlave.read_i2cPrimitive(1))
    print(lSwitchSlave.read_i2cPrimitive(1))
    print(lSwitchSlave.read_i2cPrimitive(1))
 
# ------------------------------------------------------------------------------
@debug.command('sfp-status', short_help="Debug.")
@click.pass_obj

inspect()

timing.cli.debug.inspect	(		obj,
			nodes )

Definition at line 63 of file debug.py.

def inspect(obj, nodes):
    lDevice = obj.mDevice
 
    lNodeIds = lDevice.getNodes(nodes.encode('ascii','replace'))
    lNodeVals = {n:lDevice.getNode(n).read() for n in lNodeIds}
 
    lDevice.dispatch()
 
    toolbox.printRegTable(lNodeVals, False)
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command()
@click.pass_context

ipy()

timing.cli.debug.ipy

(

ctx

)

Start an interactive IPython session.

The board HwInterface is accessible as 'lDevice'

Definition at line 78 of file debug.py.

def ipy(ctx):
    '''
    Start an interactive IPython session.
 
    The board HwInterface is accessible as 'lDevice'
    '''
    lDevice = ctx.obj.mDevice
 
    from IPython import embed
    embed()
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('uid', short_help="Unique ID reader.")
@click.pass_obj

readSFPStatus()

timing.cli.debug.readSFPStatus	(		aEEProm,
			aDiag,
			aLabel )

Definition at line 290 of file debug.py.

def readSFPStatus(aEEProm, aDiag, aLabel):
 
    def asciidecode( v ): 
        return (''.join([chr(c) for c in v])).rstrip()
 
    def tempdecode( v ):
        lSign = -1 if ((v[0]>>7) & 0x1) else 1
        x = lSign*((v[0] & 0x7f) + v[1]/float(0xff))
        return '{:.3f} C'.format(x)
 
    def vccdecode( v ):
        return '{:.4f} V'.format(((v[0] << 8) + v[1])/float(10000))
 
    def biascurdecode( v ):
        return '{:.3f} mA'.format(((v[0] << 8) + v[1])*2e-3)
 
    def powerdecode( v ):
        return '{:.3f} mW'.format(((v[0] << 8) + v[1])*1e-3)
 
 
    echo()
    lVenInfoEnc = collections.OrderedDict()
    lVenInfoEnc['Name'] = asciidecode(aEEProm.read_i2cArray(20,16))
    lVenInfoEnc['OUI'] = '{}.{}.{}'.format(*(aEEProm.read_i2cArray(37,3)))
    lVenInfoEnc['Part Number'] = asciidecode(aEEProm.read_i2cArray(40,16))
    lVenInfoEnc['Revision'] = asciidecode(aEEProm.read_i2cArray(56,4))
    lVenInfoEnc['Serial Number'] = asciidecode(aEEProm.read_i2cArray(68,16))
    lVenInfoEnc['Day'] = asciidecode(aEEProm.read_i2cArray(88,2))
    lVenInfoEnc['Month'] = asciidecode(aEEProm.read_i2cArray(86,2))
    lVenInfoEnc['Year'] = asciidecode(aEEProm.read_i2cArray(84,2))
 
    secho("{} Vendor info".format(aLabel), fg='cyan')
    # for k,v in lVenInfoEnc.items():
    #     v = ''.join([chr(c) for c in v])
    #     echo(' - '+k+': '+style(v, fg='cyan'))
    echo(toolbox.formatDictTable(lVenInfoEnc, aHdr=False, aSort=False))
    echo()
    lLaserWl = aEEProm.read_i2cArray(60,2)
    lLaserWl = (lLaserWl[0] << 8) + lLaserWl[1]
    echo('Laser Wavelength: '+style(str(lLaserWl)+'nm', fg='cyan'))
 
    lRegs = collections.OrderedDict()
 
    lRegs['Identifier'] = aEEProm.read_i2c(0)
    lRegs['Ext Identifier'] = aEEProm.read_i2c(1)
    lRegs['Connector'] = aEEProm.read_i2c(2)
 
    # Transciever Compatinility
    lTransComp = aEEProm.read_i2cArray(3, 8)
 
    lRegs['Encoding'] = aEEProm.read_i2c(11)
    lRegs['BR, Nominal'] = aEEProm.read_i2c(12)
    lRegs['Rate ID'] = aEEProm.read_i2c(13)
 
    toolbox.printRegTable(lRegs, aHeader=False, sort=False)
 
    echo()
    secho("{} Diagnostic info".format(aLabel), fg='cyan')
 
    lReadings = collections.OrderedDict()
 
    lReadings['Temp'] = tempdecode(aDiag.read_i2cArray(96, 2))
    lReadings['Vcc']  = vccdecode(aDiag.read_i2cArray(98, 2))
    lReadings['TX bias']  = biascurdecode(aDiag.read_i2cArray(100, 2))
    lReadings['TX power']  = powerdecode(aDiag.read_i2cArray(102, 2))
    lReadings['RX power']  = powerdecode(aDiag.read_i2cArray(104, 2))
    lMiscStatus = aDiag.read_i2c(110)
    lReadings['TX disable'] = (lMiscStatus >> 7) & 0x1
 
    # for k,v in lReadings.items():
        # print (k, v)
 
    echo(toolbox.formatDictTable(lReadings, aHdr=False, aSort=False))
# ------------------------------------------------------------------------------

sfp_status()

timing.cli.debug.sfp_status

(

obj

)

Definition at line 155 of file debug.py.

def sfp_status(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    lNodes = []
    lSwitches={}
    lSwitchChannels={}
    if lBoardType in [kBoardFMC, kBoardPC069]:
        lNodes = ['io.sfp_i2c','io.uid_i2c','io.pll_i2c']
    elif lBoardType == kBoardPC059:
        lNodes = ['io.i2c', 'io.usfp_i2c']
        switch_address=lDevice.getNode('io.i2c').get_slave_address('SFP_Switch')
        lSwitches={"io.i2c": switch_address}
        lSwitchChannels={"io.i2c": 8}
    elif lBoardType in [kBoardTLU, kBoardMIB, kBoardGIB]:
        lNodes = ['io.i2c']
        if lBoardType == kBoardGIB:
            lSwitches={"io.i2c": 0x70}
            lSwitchChannels={"io.i2c": 7}
    else:
        secho(f"Error I don't know about board {lBoardType} : {kBoardNameMap[lBoardType]}", fg='red')
    # if lBoardType == kBoardPC059:
    #     lSFPSwitch = lDevice.getNode('io.i2c').get_slave('SFP_Switch')
    #     print(lSFPSwitch.read_i2cPrimitive(1))
    #     print(lSFPSwitch.write_i2cPrimitive([0x1]))
    #     print(lSFPSwitch.read_i2cPrimitive(1))
 
    for n in lNodes:
        lI2CBusNode = lDevice.getNode(n)
        echo('Scanning '+style(n,fg='cyan'))
        lAddresses = lI2CBusNode.scan()
        print("  '{}': {} devices found.\n  Addresses: {}".format(n, len(lAddresses), ', '.join((hex(a) for a in lAddresses))))
        if n in lSwitches:
            print(f" Found {len(lSwitches)} switches.\n  Addresses: {lSwitches.values()}")
            for switch,address in lSwitches.items():
                print (f"switch {switch} address: {address}")
                switch_channels=lSwitchChannels[switch]
                print(f"working with {switch}, @ adr {address}, it has {switch_channels} channels")
                for channel in range(0,switch_channels):
                    secho(f"Scanning with channel {channel} enabled", fg='cyan')
                    lI2CBusNode.write_i2cPrimitive(address, [1<<channel])
                    lAddresses = lI2CBusNode.scan()
                    print("  '{}': {} devices found.\n  Addresses: {}".format(n, len(lAddresses), ', '.join((hex(a) for a in lAddresses))))
 
 
 
# ------------------------------------------------------------------------------
 
@debug.command('fanout-sfp-scan', short_help="Debug.")
@click.pass_obj

sfpexpander()

timing.cli.debug.sfpexpander

(

obj

)

Definition at line 126 of file debug.py.

def sfpexpander(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
 
    if lBoardType != kBoardPC059:
        secho('No SFP expander on {}'.format(kBoardNameMap[lBoardInfo['board_type'].value()]))
        return
    lI2CBusNode = lDevice.getNode("io.i2c")
    lSFPExp = I2CExpanderSlave(lI2CBusNode, lI2CBusNode.get_slave('SFPExpander').get_i2c_address())
    lSFPExpStatus = lSFPExp.debug()
 
    lLabels = [
        'B0 values', 
        'B1 values',
        'B0 enable',
        'B1 enable',
        'B0 invert',
        'B1 invert',
        'B0 I/O   ',
        'B1 I/O   ',
        ]
    for a,v in enumerate(lSFPExpStatus):
        echo("{} ({}): {}".format(lLabels[a], hex(a), hex(v)))
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('scan-i2c', short_help="Debug.")
@click.pass_obj

uuid()

timing.cli.debug.uuid

(

obj

)

Definition at line 94 of file debug.py.

def uuid(obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    # Detect the on-board eprom and read the board UID
    if lBoardType in [kBoardPC059, kBoardTLU, kBoardMIB, kBoardGIB]:
        lUID = lDevice.getNode('io.i2c')
    else:
        lUID = lDevice.getNode('io.uid_i2c')
 
    lPROMSlave = 'UID_PROM' if lBoardType in [kBoardTLU,kBoardMIB,kBoardGIB] else 'FMC_UID_PROM'
 
    if lBoardType == kBoardGIB:
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x0)
        lDevice.dispatch()
        lDevice.getNode("io.csr.ctrl.i2c_sw_rst").write(0x1)
        lDevice.dispatch()
        lIO.set_i2c_mux_channels(0x1)
 
    lValues = lUID.get_slave(lPROMSlave).read_i2cArray(0xfa, 6)
    lUniqueID = 0x0
    for lVal in lValues:
        lUniqueID = ( lUniqueID << 8 ) | lVal
    echo("Timing Board PROM UID: "+style(hex(lUniqueID), fg="blue"))
# ------------------------------------------------------------------------------
 
 
# ------------------------------------------------------------------------------
@debug.command('sfpexpander', short_help="Debug.")
@click.pass_obj