예제 #1
0
def main():
    # this setup stuff should eventually go into the data base
    phi_node_dict = {}
    node_prefix = "payload.mu_deserialization."
    offsets = []
    node_names = []
    for j in range(2):  # for both endcap+ and overlap+ 60 degrees sectors
        for i in range(6):  # 6 channels each
            offsets.append(i*96 + 24)
    for i in range(12):  # for barrel 12*30 degree wedges
        offsets.append((i * 48 + 576 - 24) % 576)
    for j in range(2):  # for both endcap- and overlap- 60 degrees sectors
        for i in range(6):  # 6 channels each
            offsets.append(i*96 + 24)

    for quad in range(9):
        for channel in range(4):
            node_name = node_prefix + "mu_quad{q}.phi_offset_{ch}".format(q=quad, ch=channel)
            phi_node_dict[node_name] = offsets[quad*4+channel]
            node_names.append(node_name)


    opts = parse_options()

    uhal.setLogLevelTo(uhal.LogLevel.ERROR)
    cm = uhal.ConnectionManager("file://${MP7_TESTS}/etc/mp7/connections-test.xml")
    board = cm.getDevice(opts.board)
    board.getNode('ctrl.id').read()
    try:
        board.dispatch()
    except:
        # print something here when if times out
        print 'MP7 access failed (name:', board.id(), 'uri:', board.uri(), ')'
        sys.exit(-1)

    if opts.mode == "read":
        values = {}
        for node, value in phi_node_dict.iteritems():
            values[node] = board.getNode(node).read()
        try:
            board.dispatch()
        except:
            print 'read failed'
            sys.exit(-1)

        for node in node_names:
            print node, " = ", hex(values[node]), " ..  should be", hex(phi_node_dict[node])
        return
    if opts.mode == "write":
        for node, value in phi_node_dict.iteritems():
            board.getNode(node).write(value)
        try:
            board.dispatch()
        except:
            print 'write failed'
            sys.exit(-1)
        print "wrote values to phi offset registers."
예제 #2
0
def getinfo():
    uhal.setLogLevelTo(uhal.LogLevel.WARNING)

    cm = uhal.ConnectionManager(
        'file://${TIMING_SHARE}/config/etc/connections.xml')

    device = cm.getDevice('OVLD_TUN')

    readMAC(device)
예제 #3
0
def init_board(library, deviceaddress, xmlfile):
    global board
    uhal.setLogLevelTo(uhal.LogLevel.INFO)
    board = uhal.getDevice("glib",
                           "ipbusudp-2.0://" + deviceaddress + ":50001",
                           "file://" + xmlfile)
    board.getClient().setTimeoutPeriod(10000)
    nodeslist = board.getNodes()
    deletelist = []
    return nodeslist
예제 #4
0
 def run(board, sdfile):
     if not sdfile:
         logging.error(
             'No firmware image given. Listing image names on uSD...')
         hlp.listFilesOnSD(board)
     else:
         logging.info("Rebooting FPGA with firmware image %s..." % sdfile)
         uhal.setLogLevelTo(uhal.LogLevel.FATAL)
         board.rebootFPGA(sdfile)
         uhal.setLogLevelTo(uhal.LogLevel.ERROR)
예제 #5
0
    def __init__(self,name,go=True,freq=100,odir="blah"):
        
        self._name = name;
        self._go = go;
        self._freq = freq;
        self._odir = odir;

        self._manager = uhal.ConnectionManager("file://../data/vipram_connections.xml");
        self._hw = self._manager.getDevice("Mezz1")
        uhal.setLogLevelTo( uhal.LogLevel.ERROR )
        self._ident = self._hw.getNode("VipMEM.Ident").read();
        self._vers  = self._hw.getNode("VipMEM.FWver").read();
        self._hw.dispatch();
        print "Firmware identity = ", hex(self._ident), ", firmware version = ", self._vers;

        self._iSteps = 0;
        self._fSteps = 32;
        self._stepIncrement = 32;
        self._blockSize = 1024;

        ###################
        ## define registers
        self._registers = [];
        self._registers.append( 'CheckData' ); # CheckData
        for i in range(32-1,-1,-1): self._registers.append( 'Out'+str(i) );
        self._registers.append( 'ReqL0' );
        self._registers.append( 'Miss2' );
        self._registers.append( 'Miss1' );
        self._registers.append( 'Miss0' );
        self._registers.append( 'RunMode' );
        self._registers.append( 'Primary' );
        self._registers.append( 'Latch' );
        self._registers.append( 'EvRearm' );
        for i in range(7): self._registers.append( "RA"+str(i) );
        for i in range(5): self._registers.append( "CA"+str(i) );

        for i in range(1,16): self._registers.append( "A"+str(i) );
        self._registers.append( "A0" );
        for i in range(1,16): self._registers.append( "B"+str(i) );
        self._registers.append( "B0" );
        for i in range(1,16): self._registers.append( "C"+str(i) );
        self._registers.append( "C0" );
        for i in range(1,16): self._registers.append( "D"+str(i) );
        self._registers.append( "D0" );

        print "registers size = ", len(self._registers);
        ###################

        # power numbers
        self._i_dvdd = [];
        self._i_vdd = [];
        self._i_prech = [];
        self._difftimes = [];
예제 #6
0
파일: utils.py 프로젝트: fcrescio/amchip
def GetUhalDevice(LogLevel = uhal.LogLevel.WARNING):
	uhal.setLogLevelTo(LogLevel)
	global uhalDevice
	if uhalDevice == 0:
		f = "addresses.xml"
		if not FileExists(f):
			f = "common/addresses.xml"
		if not FileExists(f):
			f = "../common/addresses.xml"
		if not FileExists(f):
			print Error_("Could not find file \"addresses.xml\"")
			raise
		uhalDevice = uhal.getDevice("fpga", "ipbusudp-2.0://134.158.152.64:50001", "file://"+f)
		# print "Creating device"
	return uhalDevice
def useUhalParser(test_xml, HDLPath, regMapTemplate, pkgTemplate="",
                  verbose=False, debug=False, yml2hdl=False):

    # configure logger
    global log
    log = logging.getLogger("main")
    formatter = logging.Formatter('%(name)s %(levelname)s: %(message)s')
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(formatter)
    log.addHandler(handler)
    log.setLevel(logging.WARNING)
    uhal.setLogLevelTo(uhal.LogLevel.WARNING)

    if verbose:
        log.setLevel(logging.INFO)
        uhal.setLogLevelTo(uhal.LogLevel.INFO)
    if debug:
        log.setLevel(logging.DEBUG)
        uhal.setLogLevelTo(uhal.LogLevel.DEBUG)

    try:
        device = uhal.getDevice(
            "dummy", "ipbusudp-1.3://localhost:12345", "file://" + test_xml)
    except Exception:
        raise Exception(
            "File '%s' does not exist or has incorrect format" % test_xml)

    if not os.path.exists(HDLPath):
        os.makedirs(HDLPath)
    cwd = os.getcwd()
    os.chdir(os.path.abspath(HDLPath))

    for i in device.getNodes():
        if i.count('.') == 0:
            mytree = tree.tree(device.getNode(i), log, yml2hdl=yml2hdl)
            mytree.generatePkg()
            mytree.generateRegMap(regMapTemplate=regMapTemplate)

            # test array-type
            # findArrayType(mytree.root)

    os.chdir(cwd)
class GEMDAQTestSuite:
    """
    This python script will test the GLIB, optical links, OH, and VFAT2 functionalities.
    Simply follow the instructions on the screen in order to diagnose the setup.
    Thomas Lenzi - [email protected]
    Jared Sturdy - [email protected] (Adapted for uHAL)
    """

    uhal.setLogLevelTo(uhal.LogLevel.FATAL)

    allTests = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

    def __init__(self,
                 slot,
                 gtx,
                 tests="",
                 test_params=TEST_PARAMS(),
                 debug=False):
        """
        """
        self.slot = slot
        self.gtx = gtx

        self.tests = tests.upper().split(',')

        if ("J" in self.tests):
            self.tests.append("B")
            pass
        if ("I" in self.tests):
            self.tests.append("E")
            pass
        if ("H" in self.tests):
            self.tests.append("G")
            pass
        if ("G" in self.tests):
            self.tests.append("E")
            pass
        if ("F" in self.tests):
            self.tests.append("E")
            pass
        if ("E" in self.tests):
            self.tests.append("B")
            pass
        if ("D" in self.tests):
            self.tests.append("B")
            pass
        if ("C" in self.tests):
            self.tests.append("A")
            pass
        if ("B" in self.tests):
            self.tests.append("A")
            pass

        self.tests = list(set(self.tests))

        self.test_params = test_params

        self.debug = debug

        self.uTCAslot = 170
        if self.slot:
            uTCAslot = 160 + self.slot
            pass
        if self.debug:
            print self.slot, uTCAslot
            pass

        self.ipaddr = '192.168.0.%d' % (uTCAslot)

        self.address_table = "file://${GEM_ADDRESS_TABLE_PATH}/glib_address_table.xml"
        self.uri = "chtcp-2.0://localhost:10203?target=%s:50001" % (
            self.ipaddr)
        self.glib = uhal.getDevice("glib", self.uri, self.address_table)
        self.oh_basenode = "GLIB.OptoHybrid_%d.OptoHybrid" % (self.gtx)

        self.presentVFAT2sSingle = []
        self.presentVFAT2sFifo = []
        self.chipIDs = None
        self.vfatmask = 0xff000000

        self.test = {}
        self.test["A"] = False
        self.test["B"] = False
        self.test["C"] = False
        self.test["D"] = False
        self.test["E"] = False
        self.test["F"] = False
        self.test["G"] = False
        self.test["H"] = False
        self.test["I"] = False
        self.test["J"] = False

        return

    ####################################################
    def GLIBPresenceTest(self):
        txtTitle("A. Testing the GLIB's presence")
        print "   Trying to read the GLIB board ID... If this test fails, the script will stop."

        if (readRegister(self.glib, "GLIB.SYSTEM.BOARD_ID") != 0):
            print Passed
        else:
            print Failed
            sys.exit()
            pass
        self.test["A"] = True
        print

    ####################################################
    def OptoHybridPresenceTest(self):
        txtTitle("B. Testing the OH's presence")
        print "   Trying to set the OptoHybrid registers... If this test fails, the script will stop."

        # setReferenceClock( self.glib, self.gtx, 1)
        setTriggerSource(self.glib, self.gtx, 1)
        setTriggerThrottle(self.glib, self.gtx, 0)

        if (getTriggerSource(self.glib, self.gtx) == 1):
            print Passed
        else:
            print Failed, "oh_trigger_source %d" % (getTriggerSource(
                self.glib, self.gtx))
            sys.exit()
            pass

        # if (getReferenceClock(self.glib,self.gtx) == 1):
        #     print Passed
        # else:
        #     print Failed, "oh_clk_src %d"%(getReferenceClock(self.glib,self.gtx))
        #     sys.exit()
        #     pass

        if (getTriggerThrottle(self.glib, self.gtx) == 0):
            print Passed
        else:
            print Failed, "oh_trg_throttle %d" % (getTriggerThrottle(
                self.glib, self.gtx))
            sys.exit()
            pass

        self.test["B"] = True

        print

        return

    ####################################################
    def GLIBRegisterTest(self):
        txtTitle("C. Testing the GLIB registers")
        print "   Performing single reads on the GLIB counters and ensuring they increment."

        countersSingle = []
        countersTest = True

        for i in range(0, self.test_params.GLIB_REG_TEST):
            countersSingle.append(
                readRegister(self.glib, "GLIB.COUNTERS.IPBus.Strobe.Counters"))
            pass

        for i in range(1, self.test_params.GLIB_REG_TEST):
            if (countersSingle[i - 1] + 1 != countersSingle[i]):
                print "\033[91m   > #%d previous %d, current %d \033[0m" % (
                    i, countersSingle[i - 1], countersSingle[i])
                countersTest = False
                pass
            pass
        if (countersTest):
            print Passed
        else:
            print Failed
            pass

        self.test["C"] = countersTest

        print

        return

    ####################################################
    def OptoHybridRegisterTest(self):
        txtTitle("D. Testing the OH registers")
        print "   Performing single reads on the OptoHybrid counters and ensuring they increment."

        countersSingle = []
        countersTest = True

        for i in range(0, self.test_params.OH_REG_TEST):
            countersSingle.append(
                readRegister(
                    self.glib,
                    "%s.COUNTERS.WB.MASTER.Strobe.GTX" % (self.oh_basenode)))
            pass

        for i in range(1, self.test_params.OH_REG_TEST):
            if (countersSingle[i - 1] + 1 != countersSingle[i]):
                print "\033[91m   > #%d previous %d, current %d \033[0m" % (
                    i, countersSingle[i - 1], countersSingle[i])
                countersTest = False
                pass
            pass

        if (countersTest):
            print Passed
        else:
            print Failed
            pass

        self.test["D"] = countersTest

        print

        return

    ####################################################
    def VFAT2DetectionTest(self):
        txtTitle("E. Detecting the VFAT2s over I2C")
        print "   Detecting VFAT2s on the GEM by reading out their chip ID."

        # writeRegister(self.glib,"%s.GEB.Broadcast.Reset"%(self.oh_basenode), 0)
        # readRegister(self.glib,"%s.GEB.Broadcast.Request.ChipID0"%(self.oh_basenode))
        self.chipIDs = getAllChipIDs(self.glib, self.gtx)

        for i in range(0, 24):
            # missing VFAT shows 0x0003XX00 in I2C broadcast result
            #                    0x05XX0800
            # XX is slot number
            # so if ((result >> 16) & 0x3) == 0x3, chip is missing
            # or if ((result) & 0x30000)   == 0x30000, chip is missing
            if (((readRegister(
                    self.glib, "%s.GEB.VFATS.VFAT%d.ChipID0" %
                (self.oh_basenode, i)) >> 24) & 0x5) != 0x5):
                self.presentVFAT2sSingle.append(i)
                pass
            if (self.chipIDs[i] not in [0x0000, 0xdead]):
                self.presentVFAT2sFifo.append(i)
                pass
            pass
        if (self.presentVFAT2sSingle == self.presentVFAT2sFifo):
            print Passed
            pass
        else:
            print Failed
            pass

        self.test["E"] = True

        print "   Detected", str(len(
            self.presentVFAT2sSingle)), "VFAT2s:", str(
                self.presentVFAT2sSingle)
        print

        self.vfatmask = setVFATTrackingMask(self.glib, self.gtx)

        return

    ####################################################
    def VFAT2I2CRegisterTest(self):
        txtTitle("F. Testing the I2C communication with the VFAT2s")
        print "   Performing random read/write operation on each connect VFAT2."

        self.test["F"] = True

        for i in self.presentVFAT2sSingle:
            validOperations = 0
            for j in range(0, self.test_params.I2C_TEST):
                writeData = random.randint(0, 255)
                writeVFAT(self.glib, self.gtx, i, "ContReg3", writeData)
                readData = (readVFAT(self.glib, self.gtx, i, "ContReg3")
                            & 0xff)
                if (readData == writeData):
                    validOperations += 1
                    pass
                else:
                    print "0x%02x not 0x%02x" % (readData, writeData)
                pass
            writeVFAT(self.glib, self.gtx, i, "ContReg3", 0)
            if (validOperations == self.test_params.I2C_TEST):
                print Passed, "#%d" % (i)
            else:
                print Failed, "#%d received %d, expected %d" % (
                    i, validOperations, self.test_params.I2C_TEST)
                self.test["F"] = False
                pass
            pass

        print

        return

    ####################################################
    def TrackingDataReadoutTest(self):
        txtTitle("G. Reading out tracking data")
        print "   Sending triggers and testing if the Event Counter adds up."

        broadcastWrite(self.glib, self.gtx, "ContReg0", 0x36)

        self.test["G"] = True

        for i in self.presentVFAT2sSingle:
            t1_mode = 0
            t1_type = 0
            t1_n = self.test_params.TK_RD_TEST
            t1_interval = 400
            resetLocalT1(self.glib, self.gtx)
            writeVFAT(self.glib, self.gtx, i, "ContReg0", 0x37)
            setVFATTrackingMask(self.glib, self.gtx, ~(0x1 << i))
            flushTrackingFIFO(self.glib, self.gtx)

            nPackets = 0
            timeOut = 0
            ecs = []

            sendL1A(self.glib, self.gtx, t1_interval, t1_n)

            while ((readFIFODepth(self.glib, self.gtx)["Occupancy"]) !=
                   7 * self.test_params.TK_RD_TEST):
                timeOut += 1
                if (timeOut == 10 * self.test_params.TK_RD_TEST):
                    break
                pass
            while ((readFIFODepth(self.glib, self.gtx)["isEMPTY"]) != 1):
                packets = readTrackingInfo(self.glib, self.gtx)
                if (len(packets) == 0):
                    print "read data packet length is 0"
                    continue
                ec = int((0x00000ff0 & packets[0]) >> 4)
                nPackets += 1
                ecs.append(ec)
                pass
            writeVFAT(self.glib, self.gtx, i, "ContReg0", 0x36)

            if (nPackets != self.test_params.TK_RD_TEST):
                print Failed, "#%d received %d, expected %d" % (
                    i, nPackets, self.test_params.TK_RD_TEST)
                if self.debug:
                    raw_input("press enter to continue")
                    pass
            else:
                followingECS = True
                for j in range(0, self.test_params.TK_RD_TEST - 1):
                    if (ecs[j + 1] == 0 and ecs[j] == 255):
                        pass
                    elif (ecs[j + 1] - ecs[j] != 1):
                        followingECS = False
                        print "\033[91m   > #%d previous %d, current %d \033[0m" % (
                            i, ecs[j], ecs[j + 1])
                        pass
                    pass
                if (followingECS):
                    print Passed, "#" + str(i)
                else:
                    print Failed, "#%d received %d, expected %d, noncontinuous ECs" % (
                        i, nPackets, self.test_params.TK_RD_TEST)
                    if self.debug:
                        raw_input("press enter to continue")
                        pass
                    self.test["G"] = False
                    pass
                pass
            pass

        print

        return

    ####################################################
    def SimultaneousTrackingDataReadoutTest(self):
        txtTitle("H. Reading out tracking data")
        print "   Turning on all VFAT2s and looking that all the Event Counters add up."

        self.test["H"] = True

        if (self.test["G"]):
            broadcastWrite(self.glib, self.gtx, "ContReg0", 0x37)

            mask = 0
            for i in self.presentVFAT2sSingle:
                mask |= (0x1 << i)
                pass
            setVFATTrackingMask(self.glib, self.gtx, ~(mask))

            sendResync(self.glib, self.gtx, 10, 1)

            flushTrackingFIFO(self.glib, self.gtx)

            t1_mode = 0
            t1_type = 0
            t1_n = self.test_params.TK_RD_TEST
            t1_interval = 400
            resetLocalT1(self.glib, self.gtx)

            nPackets = 0
            timeOut = 0
            ecs = []

            sendL1A(self.glib, self.gtx, t1_interval, t1_n)

            while ((readFIFODepth(self.glib, self.gtx)["Occupancy"]) !=
                   len(self.presentVFAT2sSingle) *
                   self.test_params.TK_RD_TEST):
                timeOut += 1
                if (timeOut == 20 * self.test_params.TK_RD_TEST): break
                pass
            while ((readFIFODepth(self.glib, self.gtx)["isEMPTY"]) != 1):
                packets = readTrackingInfo(self.glib, self.gtx)
                ec = int((0x00000ff0 & packets[0]) >> 4)
                nPackets += 1
                ecs.append(ec)
                pass
            broadcastWrite(self.glib, self.gtx, "ContReg0", 0x36)

            if (nPackets != len(self.presentVFAT2sSingle) *
                    self.test_params.TK_RD_TEST):
                print Failed, "#%d received: %d, expected: %d" % (
                    i, nPackets, len(self.presentVFAT2sSingle) *
                    self.test_params.TK_RD_TEST)
            else:
                followingECS = True
                for i in range(0, self.test_params.TK_RD_TEST - 1):
                    for j in range(0, len(self.presentVFAT2sSingle) - 1):
                        if (ecs[i * len(self.presentVFAT2sSingle) + j + 1] !=
                                ecs[i * len(self.presentVFAT2sSingle) + j]):
                            print "\033[91m   > #%d saw %d, %d saw %d \033[0m" % (
                                j + 1,
                                ecs[i * len(self.presentVFAT2sSingle) + j + 1],
                                j, ecs[i * len(self.presentVFAT2sSingle) + j])
                            followingECS = False
                            pass
                        pass
                    if (ecs[(i + 1) * len(self.presentVFAT2sSingle)] == 0
                            and ecs[i * len(self.presentVFAT2sSingle)] == 255):
                        pass
                    elif (ecs[(i + 1) * len(self.presentVFAT2sSingle)] -
                          ecs[i * len(self.presentVFAT2sSingle)] != 1):
                        print "\033[91m   > #%d previous %d, current %d \033[0m" % (
                            i, ecs[i * len(self.presentVFAT2sSingle)],
                            ecs[(i + 1) * len(self.presentVFAT2sSingle)])
                        followingECS = False
                        pass
                    pass
                if (followingECS): print Passed
                else:
                    print Failed
                    self.test["H"] = False
                    pass
                pass
            resetLocalT1(self.glib, self.gtx)
            pass
예제 #9
0
                  metavar="errorRate")
parser.add_option("-u",
                  "--user",
                  action="store_true",
                  dest="userOnly",
                  help="print user information only",
                  metavar="userOnly")
(options, args) = parser.parse_args()

links = {}
for link in options.activeLinks:
    pair = map(int, link.split(","))
    links[pair[0]] = pair[1]
print "links", links

uhal.setLogLevelTo(uhal.LogLevel.FATAL)

uTCAslot = 175
if options.slot:
    uTCAslot = 160 + options.slot
print options.slot, uTCAslot
ipaddr = '192.168.0.%d' % (uTCAslot)
address_table = "file://${BUILD_HOME}/data/glib_address_table.xml"
uri = "chtcp-2.0://localhost:10203?target=%s:50001" % (ipaddr)
glib = uhal.getDevice("glib", uri, address_table)

########################################
# IP address
########################################
print
print "--=======================================--"
예제 #10
0
                            help="character to trigger capture "
                            "- default: %(default)s")

    parser_cap.add_argument("--nwords", dest='ncapture',
                            type=int, metavar='N', default=4,
                            help="Number of words to capture from each link"
                            "- default: 0x%(default)i")

    parser_cap.add_argument("--expected", metavar='pattern.txt',
                            help="Pattern file with 1 word/line in hex")

    args = parser.parse_args()

    if args.verbose:
        logging.basicConfig(level=logging.INFO)
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
    else:
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
        logging.basicConfig(level=logging.WARNING)

    if not args.connection:
        args.connection = os.environ['CTP6_CONNECTION']

    if not args.links:
        log.debug("Using all links")
        args.links = range(48)
    else:
        args.links = list(api.expand_links(args.links))

    hw_connection = 'file://%s' % args.connection
    log.info("Setting up connection: %s", hw_connection)
예제 #11
0
    def __init__(self, name, go=True, freq=100, odir="blah", vprech=38, vdd=38, dvdd=38):

        self._name = name
        self._go = go
        self._freq = freq
        self._odir = odir

        self._vprech = vprech
        self._vdd = vdd
        self._dvdd = dvdd

        self._manager = uhal.ConnectionManager("file://../data/vipram_connections.xml")
        self._hw = self._manager.getDevice("Mezz1")
        uhal.setLogLevelTo(uhal.LogLevel.ERROR)
        # self._hw.dispatch();
        self._hw.getNode("VipMEM.VPRECH").write(vprech)
        self._hw.getNode("VipMEM.VDD").write(vdd)
        self._hw.getNode("VipMEM.DVDD").write(dvdd)

        # self._hw.dispatch();
        self._ident = self._hw.getNode("VipMEM.Ident").read()
        self._vers = self._hw.getNode("VipMEM.FWver").read()
        self._VprechargeRead = self._hw.getNode("VipMEM.VPRECH").read()
        self._VprechargeMea = self._hw.getNode("VipMEM.V_VPRECH").read()

        self._VDDRead = self._hw.getNode("VipMEM.VDD").read()
        self._VDDMea = self._hw.getNode("VipMEM.V_VDD").read()

        self._DVDDRead = self._hw.getNode("VipMEM.DVDD").read()
        self._DVDDMea = self._hw.getNode("VipMEM.V_DVDD").read()

        self._hw.dispatch()
        print "Firmware identity = ", hex(
            self._ident
        ), ", firmware version = ", self._vers, ", Vpre bit = ", self._VprechargeRead, ", Vpre measured = ", self._VprechargeMea
        print "Vdd bit = ", self._VDDRead, ", Vdd measured = ", self._VDDMea, "Dvdd bit = ", self._DVDDRead, ", Dvdd measured = ", self._DVDDMea

        self._iSteps = 0
        self._fSteps = 32
        self._stepIncrement = 32
        self._blockSize = 1024

        ###################
        ## define registers
        self._registers = []
        self._registers.append("CheckData")
        # CheckData
        for i in range(32 - 1, -1, -1):
            self._registers.append("Out" + str(i))
        self._registers.append("ReqL0")
        self._registers.append("Miss2")
        self._registers.append("Miss1")
        self._registers.append("Miss0")
        self._registers.append("RunMode")
        self._registers.append("Primary")
        self._registers.append("Latch")
        self._registers.append("EvRearm")
        for i in range(7):
            self._registers.append("RA" + str(i))
        for i in range(5):
            self._registers.append("CA" + str(i))

        for i in range(1, 16):
            self._registers.append("A" + str(i))
        self._registers.append("A0")
        for i in range(1, 16):
            self._registers.append("B" + str(i))
        self._registers.append("B0")
        for i in range(1, 16):
            self._registers.append("C" + str(i))
        self._registers.append("C0")
        for i in range(1, 16):
            self._registers.append("D" + str(i))
        self._registers.append("D0")

        print "registers size = ", len(self._registers)
        ###################

        # power numbers
        self._i_dvdd = []
        self._i_vdd = []
        self._i_prech = []
        self._difftimes = []
예제 #12
0
def gemsupervisor(request):
    global state
    global m_AMC13manager
    global m_AMCmanager
    global verbosity
    global m_filename
    global form
    global m_monitor
    global lt

    def updateStatus():
        status = m_AMC13manager.device.getStatus()
        status.SetHTML()
        # Create pipe and dup2() the write end of it on top of stdout, saving a copy
        # of the old stdout
        out = OutputGrabber()
        out.start()
        status.Report(verbosity)
        out.stop()
        shtml = out.capturedtext
        with open("webdaq/templates/amc13status.html", "w") as text_file:
            text_file.write(shtml)
        with open("webdaq/templates/amcstatus.html", "w") as text_file:
            text_file.write(m_AMCmanager.getStatus(verbosity))

    def parkData():
        #call root converter
        call_command = os.getenv(
            'BUILD_HOME') + '/gem-light-dqm/gemtreewriter/bin/' + os.getenv(
                'XDAQ_OS') + '/' + os.getenv('XDAQ_PLATFORM') + '/unpacker'
        command_args = "/tmp/" + m_filename + ".dat sdram"
        call([call_command + ' ' + command_args], shell=True)
        #create dirs in tmp
        for i in range(24):
            call(["mkdir -p /tmp/dqm_hists/%s" % (i)], shell=True)
        call(["mkdir -p /tmp/dqm_hists/OtherData"], shell=True)
        call(["mkdir -p /tmp/dqm_hists/canvases"], shell=True)
        #call dqm
        call_command = os.getenv(
            'BUILD_HOME') + '/gem-light-dqm/dqm-root/bin/' + os.getenv(
                'XDAQ_OS') + '/' + os.getenv('XDAQ_PLATFORM') + '/dqm'
        command_args = "/tmp/" + m_filename + ".raw.root"
        os.system(call_command + ' ' + command_args)
        #call dqm printer
        call_command = os.getenv(
            'BUILD_HOME') + '/gem-light-dqm/dqm-root/bin/' + os.getenv(
                'XDAQ_OS') + '/' + os.getenv('XDAQ_PLATFORM') + '/gtprinter'
        command_args = "/tmp/" + m_filename + ".analyzed.root"
        os.system(call_command + ' ' + command_args)
        #copy results to DQM display form
        #call_command = "/home/mdalchen/work/ldqm-browser/LightDQM/LightDQM/test/"
        call_command = os.getenv('LDQM_STATIC') + '/'
        # call_command += m_filename[10:15]
        # call_command += "/"
        # call_command += m_filename[:9]
        # call_command += "/"
        # call_command += "TAMU/GEB-GTX0-Long/"
        call(["mkdir -p " + call_command], shell=True)
        call(["cp -r /tmp/" + m_filename + " " + call_command], shell=True)

    if request.POST:
        if 'configure' in request.POST:
            form = ConfigForm(request.POST)
            if form.is_valid():
                amc13N = form.cleaned_data['amc13_choice']
                amc_list = form.cleaned_data['amc_list']
                amc_str = ""
                for amcN in amc_list:
                    amc_str += str(amcN) + ","
                amc_str = amc_str[:-1]
                trigger_type = form.cleaned_data['trigger_type']
                if trigger_type == '1':
                    lt = True
                    m_monitor = True
                else:
                    lt = False
                    m_monitor = False
                trigger_rate = int(form.cleaned_data['trigger_rate'])
                verbosity = int(form.cleaned_data['verbosity'])
                uhal.setLogLevelTo(uhal.LogLevel.ERROR)
                #configure GLIB. Currently supports only one GLIB
                try:
                    m_AMC13manager.connect(str(amc13N), verbosity)
                    m_AMC13manager.configureInputs(amc_str)
                    m_AMC13manager.reset()
                    for amcN in amc_list:
                        m_AMCmanager.connect(int(amcN))
                        m_AMCmanager.reset()
                        n_gtx = m_AMCmanager.activateGTX()
                        print "N GTX links %s" % (n_gtx)
                        # retrieve VFAT slot numberd and ChipIDs from HW
                        for gtx in range(n_gtx):
                            chipids = m_AMCmanager.getVFATs(gtx)
                            # retrieve VFAT slot numberd and ChipIDs from DB
                            vfats = VFAT.objects.all()
                            # Check if the VFATs are in DB, add if not
                            v_list = []
                            for chip in chipids.keys():
                                t_chipid = "0x%04x" % (chipids[chip])
                                if t_chipid in vfats.filter(
                                        Slot=chip).values_list("ChipID",
                                                               flat=True):
                                    pass
                                else:
                                    print "Adding VFAT(ChipID = %s, Slot = %d)" % (
                                        t_chipid, chip)
                                    v = VFAT(ChipID=t_chipid, Slot=chip)
                                    v.save()
                                v_list.append(
                                    VFAT.objects.get(ChipID=t_chipid,
                                                     Slot=chip))
                            #t_chamberID = 'OHv2aM'#hard code now, read from HW later when available
                            t_chamberID = 'GTX-' + str(
                                gtx
                            )  #use gtx link number now, read from HW later when available
                            print "t_chamberID = %s" % (t_chamberID)
                            g_list = []
                            gebs = GEB.objects.filter(ChamberID=t_chamberID)
                            t_flag = False
                            for geb in gebs:
                                if v_list == list(geb.vfats.all()):
                                    t_flag = True
                                    g_list.append(geb)
                                    break
                            if t_flag:
                                pass
                            else:
                                print "Update DB"
                                g = GEB(Type="Long", ChamberID=t_chamberID)
                                g.save()
                                for v in v_list:
                                    g.vfats.add(v)
                                    g_list.append(g)

                        t_flag = False
                        #t_boardID = "47-20120013"#hard code now, read from HW later when available
                        t_boardID = "AMC-" + str(
                            amcN
                        )  #hard code now, read from HW later when available
                        a_list = []
                        amcs = AMC.objects.filter(BoardID=t_boardID)
                        for amc in amcs:
                            if g_list == list(amc.gebs.all()):
                                t_flag = True
                                a_list.append(amc)
                        if t_flag:
                            pass
                        else:
                            print "Update DB"
                            a = AMC(Type="GLIB", BoardID=t_boardID)
                            a.save()
                            for g in g_list:
                                a.gebs.add(g)
                                a_list.append(a)

                    # create a new run. Some values are hard-coded for now
                    runs = Run.objects.filter(Period="2016T",
                                              Type="bench",
                                              Station="TAMU")
                    rns = list(
                        int(x)
                        for x in list(runs.values_list("Number", flat=True)))
                    nrs = u'%s' % (max(rns) + 1)
                    nrs = nrs.zfill(6)
                    t_date = str(datetime.date.today())
                    m_filename = "run" + str(
                        nrs) + "" + "_bench_TAMU_" + t_date
                    newrun = Run(Name=m_filename,
                                 Type="bench",
                                 Number=str(nrs),
                                 Date=datetime.date.today(),
                                 Period="2016T",
                                 Station="TAMU")
                    newrun.save()
                    for a in a_list:
                        newrun.amcs.add(a)
                    m_AMC13manager.configureTrigger(lt, 2, 1,
                                                    int(trigger_rate), 0)
                    updateStatus()
                    state = 'configured'
                except ValueError, e:
                    print colors.YELLOW, e, colors.ENDC
                    state = 'halted'
        elif 'halt' in request.POST:
            form = ConfigForm()
            m_AMC13manager.reset()
            state = 'halted'
        elif 'run' in request.POST:
            print "running"
            #form = ConfigForm()
            updateStatus()
            nevents = int(request.POST['nevents'])
            t = threading.Thread(target=m_AMC13manager.startDataTaking,
                                 args=["/tmp/" + m_filename + ".dat"])
            t.start()
            state = 'running'

        elif 'stop' in request.POST:
            m_AMC13manager.stopDataTaking()
            updateStatus()
            sleep(1)
            t_p = threading.Thread(target=parkData)
            t_p.start()
            state = 'configured'
        elif "monitoring" in request.POST:
            updateStatus()
예제 #13
0
def main():
    parser = argparse.ArgumentParser()

    parser.add_argument("command", choices=['reset', 'status', 'capture'],
                        help="Action to perform")

    parser.add_argument("links", nargs='*', help="Specify links. "
                        "If none are specified, reset all.")

    parser.add_argument("--connection",
                        help="Manually connection XML file. "
                        "If not specified, take from CTP6_CONNECTION env.")
    parser.add_argument("--verbose", action='store_true',
                        help="Increase verbosity")

    parser_rst = parser.add_argument_group('reset')
    parser_stat = parser.add_argument_group('status')
    parser_cap = parser.add_argument_group('capture')

    # Reset arguments
    parser_rst.add_argument("--power-down", action='store_true',
                            dest='power_down',
                            help="Additionally power down the links")

    # Capture arguments
    parser_cap.add_argument("--orbit-capture-char", dest='capture_char',
                            type=str, metavar='0xbc', default='0xbc',
                            help="character to trigger capture "
                            "- default: %(default)s")

    parser_cap.add_argument("--nwords", dest='ncapture',
                            type=int, metavar='N', default=4,
                            help="Number of words to capture from each link"
                            "- default: 0x%(default)i")

    parser_cap.add_argument("--expected", metavar='pattern.txt',
                            help="Pattern file with 1 word/line in hex")

    args = parser.parse_args()

    if args.verbose:
        logging.basicConfig(level=logging.INFO)
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
    else:
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
        logging.basicConfig(level=logging.WARNING)

    if not args.connection:
        args.connection = os.environ['CTP6_CONNECTION']

    if not args.links:
        log.debug("Using all links")
        args.links = range(48)
    else:
        args.links = list(api.expand_links(args.links))

    hw_connection = 'file://%s' % args.connection
    log.info("Setting up connection: %s", hw_connection)
    manager = uhal.ConnectionManager(hw_connection)

    hw = manager.getDevice('ctp6.frontend')

    commands = {
        'reset': do_reset,
        'status': do_status,
        'capture': do_capture
    }

    commands[args.command](hw, args)

    log.info("done.")

    return 0
예제 #14
0
    def __init__(self, dev_name, man_file, parsed_cfg):

        uhal.setLogLevelTo(uhal.LogLevel.NOTICE
                           )  ## Get rid of initial flood of IPBUS messages
        self.isRunning = False

        section_name = "Producer.fmctlu"
        self.dev_name = dev_name

        #man_file= parsed_cfg.get(section_name, "ConnectionFile")
        self.manager = uhal.ConnectionManager(man_file)
        self.hw = self.manager.getDevice(self.dev_name)

        # #Get Verbose setting
        self.verbose = parsed_cfg.getint(section_name, "verbose")

        #self.nDUTs= 4 #Number of DUT connectors
        self.nDUTs = parsed_cfg.getint(section_name, "nDUTs")

        #self.nChannels= 6 #Number of trigger inputs
        self.nChannels = parsed_cfg.getint(section_name, "nTrgIn")

        #self.VrefInt= 2.5 #Internal DAC voltage reference
        self.VrefInt = parsed_cfg.getfloat(section_name, "VRefInt")

        #self.VrefExt= 1.3 #External DAC voltage reference
        self.VrefExt = parsed_cfg.getfloat(section_name, "VRefExt")

        #self.intRefOn= False #Internal reference is OFF by default
        self.intRefOn = int(parsed_cfg.get(section_name, "intRefOn"))

        self.fwVersion = self.hw.getNode("version").read()
        self.hw.dispatch()
        print "TLU V1E FIRMWARE VERSION= ", hex(self.fwVersion)

        # Instantiate a I2C core to configure components
        self.TLU_I2C = I2CCore(self.hw, 10, 5, "i2c_master", None)
        #self.TLU_I2C.state()

        enableCore = True  #Only need to run this once, after power-up
        self.enableCore()
        ####### EEPROM AX3 testing
        doAtmel = False
        if doAtmel:
            self.ax3eeprom = ATSHA204A(self.TLU_I2C, 0x64)
            print "shiftR\tdatBit\tcrcBit\tcrcReg \n", self.ax3eeprom._CalculateCrc(
                [255, 12, 54, 28, 134, 89], 3)
            self.ax3eeprom._wake(True, True)
            print self.ax3eeprom._GetCommandPacketSize(8)
            #self.eepromAX3read()
        ####### EEPROM AX3 testing end

        # Instantiate clock chip and configure it (if necessary)
        #self.zeClock=si5345(self.TLU_I2C, 0x68)
        clk_addr = int(parsed_cfg.get(section_name, "I2C_CLK_Addr"), 16)
        self.zeClock = si5345(self.TLU_I2C, clk_addr)
        res = self.zeClock.getDeviceVersion()
        if (int(parsed_cfg.get(section_name, "CONFCLOCK"), 16)):
            #clkRegList= self.zeClock.parse_clk("./../../bitFiles/TLU_CLK_Config_v1e.txt")
            clkRegList = self.zeClock.parse_clk(
                parsed_cfg.get(section_name, "CLOCK_CFG_FILE"))
            self.zeClock.writeConfiguration(clkRegList, self.verbose)  ######

        self.zeClock.checkDesignID()

        # Instantiate DACs and configure them to use reference based on TLU setting
        #self.zeDAC1=AD5665R(self.TLU_I2C, 0x13)
        #self.zeDAC2=AD5665R(self.TLU_I2C, 0x1F)
        dac_addr1 = int(parsed_cfg.get(section_name, "I2C_DAC1_Addr"), 16)
        self.zeDAC1 = AD5665R(self.TLU_I2C, dac_addr1)
        dac_addr2 = int(parsed_cfg.get(section_name, "I2C_DAC2_Addr"), 16)
        self.zeDAC2 = AD5665R(self.TLU_I2C, dac_addr2)
        self.zeDAC1.setIntRef(self.intRefOn, self.verbose)
        self.zeDAC2.setIntRef(self.intRefOn, self.verbose)

        # Instantiate the serial line expanders and configure them to default values
        #self.IC6=PCA9539PW(self.TLU_I2C, 0x74)
        exp1_addr = int(parsed_cfg.get(section_name, "I2C_EXP1_Addr"), 16)
        self.IC6 = PCA9539PW(self.TLU_I2C, exp1_addr)
        self.IC6.setInvertReg(0, 0x00)  # 0= normal, 1= inverted
        self.IC6.setIOReg(0, 0x00)  # 0= output, 1= input
        self.IC6.setOutputs(0, 0xFF)  # If output, set to XX

        self.IC6.setInvertReg(1, 0x00)  # 0= normal, 1= inverted
        self.IC6.setIOReg(1, 0x00)  # 0= output, 1= input
        self.IC6.setOutputs(1, 0xFF)  # If output, set to XX

        #self.IC7=PCA9539PW(self.TLU_I2C, 0x75)
        exp2_addr = int(parsed_cfg.get(section_name, "I2C_EXP2_Addr"), 16)
        self.IC7 = PCA9539PW(self.TLU_I2C, exp2_addr)
        self.IC7.setInvertReg(0, 0x00)  # 0= normal, 1= inverted
        self.IC7.setIOReg(0, 0x00)  # 0= output, 1= input
        self.IC7.setOutputs(0, 0x00)  # If output, set to XX

        self.IC7.setInvertReg(1, 0x00)  # 0= normal, 1= inverted
        self.IC7.setIOReg(1, 0x00)  # 0= output, 1= input
        self.IC7.setOutputs(1, 0xB0)  # If output, set to XX

        #Instantiate Display
        self.DISP = CFA632(self.TLU_I2C, 0x2A)  #

        #Instantiate Power/Led Module
        dac_addr_module = int(
            parsed_cfg.get(section_name, "I2C_DACModule_Addr"), 16)
        exp1_addr = int(parsed_cfg.get(section_name, "I2C_EXP1Module_Addr"),
                        16)
        exp2_addr = int(parsed_cfg.get(section_name, "I2C_EXP2Module_Addr"),
                        16)
        pmtCtrVMax = parsed_cfg.getfloat(section_name, "PMT_vCtrlMax")

        self.pwdled = PWRLED(self.TLU_I2C, dac_addr_module, pmtCtrVMax,
                             exp1_addr, exp2_addr)

        #self.pwdled.setIndicatorRGB(1, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(2, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(3, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(4, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(5, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(6, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(7, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(8, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(9, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(10, [0, 0, 1])
        #self.pwdled.setIndicatorRGB(11, [0, 0, 1])

        self.pwdled.allGreen()
        time.sleep(0.1)
        self.pwdled.allBlue()
        time.sleep(0.1)
        self.pwdled.allBlack()
        time.sleep(0.1)
        #self.pwdled.kitt()
        time.sleep(0.1)
        #self.pwdled.allBlack()
        #self.pwdled.allRed()
        #time.sleep(0.1)
        self.pwdled.allWhite()
parser.add_option('-b', action='store_true', dest='noX', default=False, help='no X11 windows')
parser.add_option('--go', action='store_true', dest='go', default=False, help='go!')
parser.add_option('--reset', action='store_true', dest='reset', default=False, help='go!')

(options, args) = parser.parse_args()
############################################

############################################################
def randuint32():
    return randint(0, 0xffffffff)

if __name__ == '__main__':

    manager = uhal.ConnectionManager("file://../data/vipram_connections.xml")
    hw = manager.getDevice("Mezz1")
    uhal.setLogLevelTo( uhal.LogLevel.NOTICE )

    reg0 = hw.getNode("VipMEM.V_DVDD").read()
    reg1 = hw.getNode("VipMEM.V_VDD").read()
    reg2 = hw.getNode("VipMEM.V_VPRECH").read()

    ireg0 = hw.getNode("VipMEM.I_DVDD").read()
    ireg1 = hw.getNode("VipMEM.I_VDD").read()
    ireg2 = hw.getNode("VipMEM.I_VPRECH").read()

    vccreg = hw.getNode("VipMEM.V_VCC3V3").read()
    tmpreg = hw.getNode("VipMEM.Temperature").read()
    ltcreg = hw.getNode("VipMEM.LTC2991").read()

    hw.dispatch();
(options, args) = parser.parse_args()

############################################


############################################################
def randuint32():
    return randint(0, 0xffffffff)


if __name__ == '__main__':

    manager = uhal.ConnectionManager("file://../data/vipram_connections.xml")
    hw = manager.getDevice("Mezz1")
    uhal.setLogLevelTo(uhal.LogLevel.NOTICE)

    reg0 = hw.getNode("VipMEM.V_DVDD").read()
    reg1 = hw.getNode("VipMEM.V_VDD").read()
    reg2 = hw.getNode("VipMEM.V_VPRECH").read()

    ireg0 = hw.getNode("VipMEM.I_DVDD").read()
    ireg1 = hw.getNode("VipMEM.I_VDD").read()
    ireg2 = hw.getNode("VipMEM.I_VPRECH").read()

    vccreg = hw.getNode("VipMEM.V_VCC3V3").read()
    tmpreg = hw.getNode("VipMEM.Temperature").read()
    ltcreg = hw.getNode("VipMEM.LTC2991").read()

    hw.dispatch()
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-s", "--slot", type="int", dest="slot",
		  help="slot in uTCA crate", metavar="slot", default=4)

parser.add_option("-o", "--links", type="string", dest="activeLinks", action='append',
		  help="pair of connected optical links (GLIB,OH)", metavar="activeLinks", default=[])
(options, args) = parser.parse_args()

links = {}
for link in options.activeLinks:
	pair = map(int, link.split(","))
	links[pair[0]] = pair[1]
print "links", links

uhal.setLogLevelTo( uhal.LogLevel.FATAL )

if not links.keys():
    print "No optical links specified, exiting"
    exit(1)

# Create window
window = Window("Scan a VFAT2's threshold")

# Get GLIB access
glib = GLIB(options.slot,links)
glib.setWindow(window)

#########################################
#   Introduction Window                 #
#########################################
예제 #18
0
파일: utils.py 프로젝트: romanchyla/amc13
def get_amc_version(xml_config):
    uhal.setLogLevelTo(uhal.LogLevel.ERROR) #TODO: this is setting log level globally, which is not very nice...
    device = amc13.AMC13(xml_config)
    
    return (hex(device.read(device.Board.T1, 'STATUS.FIRMWARE_VERS')),
            hex(device.read(device.Board.T2, 'STATUS.FIRMWARE_VERS')))
예제 #19
0
def main(localSlavesYAML, remoteSlavesYAML, CMyaml, outputDir):
    #address table top node
    top = ET.Element("node", {"id": "top"})

    #local slaves
    RecreateDir(outputDir + "address_table/modules")
    slavesFile = open(localSlavesYAML)
    slaves = yaml.load(slavesFile)
    for slave in slaves['UHAL_MODULES']:
        if "XML" in slaves['UHAL_MODULES'][slave]:
            for iFile in range(0, len(slaves['UHAL_MODULES'][slave]["XML"])):
                #copy XML files
                xmlFile = slaves['UHAL_MODULES'][slave]["XML"][iFile]
                try:
                    shutil.copyfile(os.path.abspath(xmlFile),
                                    outputDir + xmlFile)
                except OSError:
                    pass
                if iFile == 0:
                    relPath = slaves['UHAL_MODULES'][slave]['XML'][iFile]
                    relPath = relPath[relPath.find("module"):]
                    slaves['UHAL_MODULES'][slave]['XML'][iFile] = relPath

            AddAddressTableNode(slave, slaves['UHAL_MODULES'][slave], top)

    remoteSlaves = list()
    #append CM.yaml remote slaves
    try:
        if type(CMyaml) == type('  '):
            CMFile = open(CMyaml)
            remotes = yaml.load(CMFile)
            if remotes:
                for remote in remotes:
                    filename = "os/" + remote + "_slaves.yaml"
                    remoteSlaves.append(filename)
    except IOError:
        pass
    #remote slaves (explicit)
    if type(remoteSlavesYAML) == type(list()):
        for CM in remoteSlavesYAML:
            remoteSlaves.append(CM)

    #go through all found remote slaves
    for CM in remoteSlaves:
        slavesFile = open(CM)
        slaves = yaml.load(slavesFile)

        nameCM = os.path.basename(CM)[0:os.path.basename(CM).find("_")]

        for slave in slaves['UHAL_MODULES']:
            if "XML" in slaves['UHAL_MODULES'][slave]:
                for iFile in range(0,
                                   len(slaves['UHAL_MODULES'][slave]["XML"])):
                    #change the file path to be relative on the apollo
                    relPath = slaves['UHAL_MODULES'][slave]['XML'][iFile]
                    relPath = nameCM + "_" + relPath[relPath.find("module"):]
                    slaves['UHAL_MODULES'][slave]['XML'][iFile] = relPath
                AddAddressTableNode(slave, slaves['UHAL_MODULES'][slave], top)

    #generate the final address table file
    BuildAddressTable(outputDir + "address_table/address_apollo.xml", top)

    #generate a connections file
    connFile = open(outputDir + "address_table/connections.xml", "w")
    connFile.write('<?xml version="1.0" encoding="UTF-8"?>\n')
    connFile.write('\n')
    connFile.write('<connections>\n')
    connFile.write(
        '  <!-- be sure to use the same file in both "uri" and "address_table" -->\n'
    )
    connFile.write(
        '  <connection id="test.0"        uri="uioaxi-1.0:///opt/address_table/address_apollo.xml"                     address_table="file:///opt/address_table/address_apollo.xml" />\n'
    )
    connFile.write('</connections>\n')
    connFile.close()

    #check files
    uhal.setLogLevelTo(uhal.LogLevel.WARNING)
    try:
        device = uhal.getDevice(
            "dummy", "ipbusudp-1.3://localhost:12345",
            "file://" + outputDir + "address_table/address_apollo.xml")
    except Exception:
        raise Exception("File '%s' does not exist or has incorrect format" %
                        outputDir + "address_table/address_apollo.xml")
예제 #20
0
#!/usr/bin/python

import uhal
import time
import sys
from I2CuHal import I2CCore
from si5344 import si5344

uhal.setLogLevelTo(uhal.LogLevel.INFO)
manager = uhal.ConnectionManager("file://connections.xml")
hw = manager.getDevice(sys.argv[1])

hw.getNode("io.freq_ctr.ctrl.chan_sel").write(0)
hw.getNode("io.freq_ctr.ctrl.en_crap_mode").write(0)
hw.dispatch()
time.sleep(2)
fq = hw.getNode("io.freq_ctr.freq.count").read()
fv = hw.getNode("io.freq_ctr.freq.valid").read()
hw.dispatch()
print "Freq:", int(fv), int(fq) * 119.20928 / 1000000

hw.getNode("daq.timing.csr.ctrl.en_ext_sync").write(0)

f_stat = hw.getNode("csr.stat").read()
hw.dispatch()
print "csr.stat", hex(f_stat)

f_ctrl = hw.getNode("csr.ctrl").read()
hw.dispatch()
print "csr.ctrl:", hex(f_ctrl)
예제 #21
0
    def __init__(self, name, go=True, freq=100, odir="blah"):

        self._name = name
        self._go = go
        self._freq = freq
        self._odir = odir

        self._manager = uhal.ConnectionManager(
            "file://../data/vipram_connections.xml")
        self._hw = self._manager.getDevice("Mezz1")
        uhal.setLogLevelTo(uhal.LogLevel.ERROR)
        #self._hw.dispatch();
        self._hw.getNode("VipMEM.VPRECH").write(38)
        self._hw.getNode("VipMEM.VDD").write(38)
        self._hw.getNode("VipMEM.DVDD").write(38)

        #self._hw.dispatch();
        self._ident = self._hw.getNode("VipMEM.Ident").read()
        self._vers = self._hw.getNode("VipMEM.FWver").read()
        self._VprechargeRead = self._hw.getNode("VipMEM.VPRECH").read()
        self._VprechargeMea = self._hw.getNode("VipMEM.V_VPRECH").read()

        self._VDDRead = self._hw.getNode("VipMEM.VDD").read()
        self._VDDMea = self._hw.getNode("VipMEM.V_VDD").read()

        self._DVDDRead = self._hw.getNode("VipMEM.DVDD").read()
        self._DVDDMea = self._hw.getNode("VipMEM.V_DVDD").read()

        self._hw.dispatch()
        print "Firmware identity = ", hex(
            self._ident
        ), ", firmware version = ", self._vers, ", Vpre bit = ", self._VprechargeRead, ", Vpre measured = ", self._VprechargeMea
        print "Vdd bit = ", self._VDDRead, ", Vdd measured = ", self._VDDMea, "Dvdd bit = ", self._DVDDRead, ", Dvdd measured = ", self._DVDDMea

        self._iSteps = 0
        self._fSteps = 32
        self._stepIncrement = 32
        self._blockSize = 1024

        ###################
        ## define registers
        self._registers = []
        self._registers.append('CheckData')
        # CheckData
        for i in range(32 - 1, -1, -1):
            self._registers.append('Out' + str(i))
        self._registers.append('ReqL0')
        self._registers.append('Miss2')
        self._registers.append('Miss1')
        self._registers.append('Miss0')
        self._registers.append('RunMode')
        self._registers.append('Primary')
        self._registers.append('Latch')
        self._registers.append('EvRearm')
        for i in range(7):
            self._registers.append("RA" + str(i))
        for i in range(5):
            self._registers.append("CA" + str(i))

        for i in range(1, 16):
            self._registers.append("A" + str(i))
        self._registers.append("A0")
        for i in range(1, 16):
            self._registers.append("B" + str(i))
        self._registers.append("B0")
        for i in range(1, 16):
            self._registers.append("C" + str(i))
        self._registers.append("C0")
        for i in range(1, 16):
            self._registers.append("D" + str(i))
        self._registers.append("D0")

        print "registers size = ", len(self._registers)
        ###################

        # power numbers
        self._i_dvdd = []
        self._i_vdd = []
        self._i_prech = []
        self._difftimes = []
예제 #22
0
파일: cli.py 프로젝트: uwcms/ctp6commander
def main():
    parser = argparse.ArgumentParser()

    parser.add_argument("command",
                        choices=['reset', 'status', 'capture'],
                        help="Action to perform")

    parser.add_argument("links",
                        nargs='*',
                        help="Specify links. "
                        "If none are specified, reset all.")

    parser.add_argument("--connection",
                        help="Manually connection XML file. "
                        "If not specified, take from CTP6_CONNECTION env.")
    parser.add_argument("--verbose",
                        action='store_true',
                        help="Increase verbosity")

    parser_rst = parser.add_argument_group('reset')
    parser_stat = parser.add_argument_group('status')
    parser_cap = parser.add_argument_group('capture')

    # Reset arguments
    parser_rst.add_argument("--power-down",
                            action='store_true',
                            dest='power_down',
                            help="Additionally power down the links")

    # Capture arguments
    parser_cap.add_argument("--orbit-capture-char",
                            dest='capture_char',
                            type=str,
                            metavar='0xbc',
                            default='0xbc',
                            help="character to trigger capture "
                            "- default: %(default)s")

    parser_cap.add_argument("--nwords",
                            dest='ncapture',
                            type=int,
                            metavar='N',
                            default=4,
                            help="Number of words to capture from each link"
                            "- default: 0x%(default)i")

    parser_cap.add_argument("--expected",
                            metavar='pattern.txt',
                            help="Pattern file with 1 word/line in hex")

    args = parser.parse_args()

    if args.verbose:
        logging.basicConfig(level=logging.INFO)
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
    else:
        uhal.setLogLevelTo(uhal.LogLevel.WARNING)
        logging.basicConfig(level=logging.WARNING)

    if not args.connection:
        args.connection = os.environ['CTP6_CONNECTION']

    if not args.links:
        log.debug("Using all links")
        args.links = range(48)
    else:
        args.links = list(api.expand_links(args.links))

    hw_connection = 'file://%s' % args.connection
    log.info("Setting up connection: %s", hw_connection)
    manager = uhal.ConnectionManager(hw_connection)

    hw = manager.getDevice('ctp6.frontend')

    commands = {'reset': do_reset, 'status': do_status, 'capture': do_capture}

    commands[args.command](hw, args)

    log.info("done.")

    return 0
    # 0 <= ret <= (2^32-1)
    val = randint(0, 4294967295)
    if len(bin(val).replace("0b", "")) > 32: #dirty check for me
        print hex(val)
    return val

def get_lut_16bit_word(address):
    from random import randint
    # 0 <= ret <= (2^32-1)
    val = randint(0, 65535)
    if len(bin(val).replace("0b", "")) > 16: #dirty check for me
        print hex(val)
    return val

opts, args = parse_options()
uhal.setLogLevelTo(uhal.LogLevel.ERROR)
hlp.initLogging(logging.DEBUG)

cm = uhal.ConnectionManager(opts.connectionFile)
board = cm.getDevice( opts.board )
# run a simple access test
hlp.testAccess(board)


v = board.getNode('ctrl.id').read()
try:
    board.dispatch()
except:
    import sys
    # print something here when if times out
    print 'MP7 access failed (name:',board.id(),'uri:',board.uri(),')'
예제 #24
0
class VFATSCurveTools:
    """
    This set of tools provides functionality to produce S-Curve results for VFAT2 chips
    @author: Hugo DeWitt
    @modifiedby: Christine McClean
    Jared Sturdy - [email protected] (Adapted for uHAL)
    """

    uhal.setLogLevelTo(uhal.LogLevel.FATAL)

    def __init__(self,
                 glib,
                 slot,
                 gtx,
                 scan_params,
                 doLatency=False,
                 debug=False):
        """
        """
        self.glib = glib
        self.slot = slot
        self.gtx = gtx
        self.scan_params = scan_params
        self.doLatency = doLatency

        self.THRESH_ABS = scan_params.THRESH_ABS
        self.THRESH_REL = scan_params.THRESH_REL
        self.THRESH_MIN = scan_params.THRESH_MIN
        self.THRESH_MAX = scan_params.THRESH_MAX
        self.LAT_ABS = scan_params.LAT_ABS
        self.LAT_MIN = scan_params.LAT_MIN
        self.LAT_MAX = scan_params.LAT_MAX
        self.N_EVENTS_THRESH = scan_params.N_EVENTS_THRESH
        self.N_EVENTS_LAT = scan_params.N_EVENTS_LAT
        self.N_EVENTS_SCURVE = scan_params.N_EVENTS_SCURVE
        self.N_EVENTS_TRIM = scan_params.N_EVENTS_TRIM
        self.VCAL_MIN = scan_params.VCAL_MIN
        self.VCAL_MAX = scan_params.VCAL_MAX
        self.MAX_TRIM_IT = scan_params.MAX_TRIM_IT
        self.CHAN_MIN = scan_params.CHAN_MIN
        self.CHAN_MAX = scan_params.CHAN_MAX
        self.DAC_DEF = scan_params.DAC_DEF
        self.T1_PARAMS_N = scan_params.T1_PARAMS_N
        self.T1_PARAMS_INTERVAL = scan_params.T1_PARAMS_INTERVAL
        self.T1_PARAMS_DELAY = scan_params.T1_PARAMS_DELAY

        self.debug = debug

        self.startTime = None
        self.subname = None
        self.f = None
        self.m = None
        self.z = None
        self.h = None
        self.g = None

        return

    def cleanup(self, debug=False):
        """
        """
        self.startTime = None
        self.subname = None
        self.f = None
        self.m = None
        self.z = None
        self.h = None
        self.g = None

        return

    def setupVFAT(self, vfat, debug=False):
        """
        """
        print "------------------------------------------------------"
        print "-------------- Testing VFAT2 position %2d -------------" % (
            vfat)
        print "------------------------------------------------------"

        if vfat not in range(0, 24):
            print "Invalid VFAT specified %d is no in [0,23]" % (vfat)
            sys.exit(-1)
            pass

        self.TotVCal = {}
        self.TotVCal["0"] = []
        self.TotVCal["16"] = []
        self.TotVCal["31"] = []
        self.TotFoundVCal = []

        self.VCal_ref = {}
        self.VCal_ref["0"] = 0
        self.VCal_ref["31"] = 0
        self.VCal_ref["avg"] = 0

        import datetime
        self.startTime = datetime.datetime.now().strftime("%d_%m_%Y_%Hh%M")

        chipID = getChipID(self.glib, self.gtx, vfat)
        self.subname = "AMC_%02d_OH_%02d_VFAT2_%d_ID_0x%04x" % (
            self.slot, self.gtx, vfat, chipID)

        self.f = open("%s_Data_%s" % (self.startTime, self.subname), 'w')
        self.m = open(
            "%s_SCurve_by_channel_%s" % (self.startTime, self.subname), 'w')
        self.z = open("%s_Setting_%s" % (self.startTime, self.subname), 'w')
        self.h = open("%s_VCal_%s" % (self.startTime, self.subname), 'w')
        self.g = open("%s_TRIM_DAC_value_%s" % (self.startTime, self.subname),
                      'w')

        self.m.close()
        self.h.close()
        self.g.close()

        self.z.write("%s-%s\n" %
                     (time.strftime("%Y/%m/%d"), time.strftime("%H:%M:%S")))
        self.z.write("chip ID: 0x%04x\n" % (chipID))

        # should make sure all chips are off first?
        writeAllVFATs(self.glib,
                      self.gtx,
                      reg="ContReg0",
                      value=0x0,
                      mask=0xff000000)

        setTriggerSource(self.glib, self.gtx, 1)

        biasVFAT(self.glib, self.gtx, vfat)

        self.z.write("ipreampin:   168\n")
        self.z.write("ipreampfeed:  80\n")
        self.z.write("ipreampout:  150\n")
        self.z.write("ishaper:     150\n")
        self.z.write("ishaperfeed: 100\n")
        self.z.write("icomp:        75\n")
        self.z.write("vthreshold2:   0\n")
        self.z.write("vthreshold1:   0\n")

        print

        sendL1ACalPulse(self.glib, self.gtx, self.T1_PARAMS_DELAY,
                        self.T1_PARAMS_INTERVAL, self.T1_PARAMS_N)
        stopLocalT1(self.glib, self.gtx)

        self.z.write("DACs default value: %s\n" % (self.DAC_DEF))
        for channel in range(self.CHAN_MIN, self.CHAN_MAX):
            ## old script had *all* channels set up to receive a pulse at this point, why?
            setChannelRegister(self.glib,
                               self.gtx,
                               vfat,
                               channel,
                               mask=0x0,
                               pulse=0x0,
                               trim=self.DAC_DEF)
            pass

        return

    def scanThresholdByVFAT(self, vfat, debug=False):
        """
        """

        configureScanModule(self.glib,
                            self.gtx,
                            SCAN_THRESH_TRIG,
                            vfat,
                            scanmin=self.THRESH_MIN,
                            scanmax=self.THRESH_MAX,
                            stepsize=1,
                            numtrigs=self.N_EVENTS_THRESH,
                            debug=debug)
        startScanModule(self.glib, self.gtx)
        if (debug):
            printScanConfiguration(self.glib, self.gtx)
            print "LocalT1Controller status %d" % (getLocalT1Status(
                self.glib, self.gtx))
            pass
        data_threshold = getScanResults(self.glib,
                                        self.gtx,
                                        self.THRESH_MAX - self.THRESH_MIN,
                                        debug=debug)

        return data_threshold

    def scanLatencyByVFAT(self, vfat, debug=False):
        """
        """

        channel = 10
        setChannelRegister(self.glib,
                           self.gtx,
                           vfat,
                           channel,
                           mask=0x0,
                           pulse=0x1,
                           trim=self.DAC_DEF)
        writeVFAT(self.glib, self.gtx, vfat, "VCal", 0xff)

        configureScanModule(self.glib,
                            self.gtx,
                            SCAN_LATENCY,
                            vfat,
                            scanmin=self.LAT_MIN,
                            scanmax=self.LAT_MAX,
                            stepsize=1,
                            numtrigs=self.N_EVENTS_LAT,
                            debug=debug)
        startScanModule(self.glib, self.gtx)
        if (debug):
            printScanConfiguration(self.glib, self.gtx)
            print "LocalT1Controller status %d" % (getLocalT1Status(
                self.glib, self.gtx))
            pass
        data_latency = getScanResults(self.glib,
                                      self.gtx,
                                      self.LAT_MAX - self.LAT_MIN,
                                      debug=debug)

        setChannelRegister(self.glib,
                           self.gtx,
                           vfat,
                           channel,
                           mask=0x0,
                           pulse=0x0,
                           trim=self.DAC_DEF)
        writeVFAT(self.glib, self.gtx, vfat, "VCal", 0x0)

        return data_latency

    def scanVCalByVFAT(self, vfat, channel, trim, ntrigs, debug=False):
        """
        """

        setChannelRegister(self.glib,
                           self.gtx,
                           vfat,
                           channel,
                           mask=0x0,
                           pulse=0x1,
                           trim=trim)
        if debug:
            print "Channel %d register 0x%08x" % (
                channel, getChannelRegister(self.glib, self.gtx, vfat,
                                            channel))
            pass
        configureScanModule(self.glib,
                            self.gtx,
                            SCAN_VCAL,
                            vfat,
                            channel=channel,
                            scanmin=self.VCAL_MIN,
                            scanmax=self.VCAL_MAX,
                            stepsize=1,
                            numtrigs=ntrigs,
                            debug=debug)
        startScanModule(self.glib, self.gtx)
        if (debug):
            printScanConfiguration(self.glib, self.gtx)
            print "LocalT1Controller status %d" % (getLocalT1Status(
                self.glib, self.gtx))
            pass
        data_scurve = getScanResults(self.glib,
                                     self.gtx,
                                     self.VCAL_MAX - self.VCAL_MIN,
                                     debug=debug)

        setChannelRegister(self.glib,
                           self.gtx,
                           vfat,
                           channel,
                           mask=0x0,
                           pulse=0x0,
                           trim=trim,
                           debug=True)
        if debug:
            print "Channel %d register 0x%08x" % (
                channel, getChannelRegister(self.glib, self.gtx, vfat,
                                            channel))
            pass
        return data_scurve

    def runAllChannels(self, vfat, debug=False):
        """
        """
        # for each channel, disable the cal pulse
        for channel in range(self.CHAN_MIN, self.CHAN_MAX):
            setChannelRegister(self.glib,
                               self.gtx,
                               vfat,
                               channel,
                               mask=0x0,
                               pulse=0x0,
                               trim=self.DAC_DEF)
            pass

        for channel in range(self.CHAN_MIN, self.CHAN_MAX):
            if self.debug and (channel > 10):
                continue
            self.scanChannel(vfat, channel, debug=debug)
            pass

        return

    def scanChannel(self, vfat, channel, debug=False):
        """
        """
        print "--------------------- Channel %03d ---------------------------" % (
            channel)

        self.m = open(
            "%s_SCurve_by_channel_%s" % (self.startTime, self.subname), 'a')
        for trim in [0, 16, 31]:
            print "---------------- S-Curve data trimDAC %2d --------------------" % (
                trim)
            data_scurve = self.scanVCalByVFAT(vfat,
                                              channel,
                                              trim,
                                              ntrigs=self.N_EVENTS_SCURVE,
                                              debug=debug)
            if (trim == 16):
                self.m.write("SCurve_%d\n" % (channel))
                pass
            try:
                if debug:
                    print "Length of returned data_scurve = %d" % (
                        len(data_scurve))
                    print "First data word: 0x%08x" % (data_scurve[0])
                    for d in range(0, len(data_scurve)):
                        "%d ==> %3.4f" % ((data_scurve[d] & 0xff000000) >> 24,
                                          (data_scurve[d] & 0xffffff) /
                                          (1. * self.N_EVENTS_SCURVE))
                        pass
                    pass
                passed = False
                for d in data_scurve:
                    VCal = (d & 0xff000000) >> 24
                    Eff = (d & 0xffffff) / (1. * self.N_EVENTS_SCURVE)
                    if self.debug:
                        print "%d => %3.4f" % (VCal, Eff)
                        pass
                    if (Eff >= 0.48 and not passed):
                        if not passed:
                            print "%d => %3.4f" % (VCal, Eff)
                            self.TotVCal["%s" % (trim)].append(VCal)
                            pass
                        passed = True
                        if trim in [0, 31]:
                            break  # stop scanning for high and low trim values
                        pass
                    if (trim == 16):
                        self.m.write(
                            "%d\t%f\n" %
                            (VCal, Eff))  # write to file for trim == 16
                        pass
                    pass

                # if self.doQC3:
                #     return
            except:
                ex = sys.exc_info()[0]
                print "Caught exception: %s" % (ex)
                print "Error while reading the data, they will be ignored"
                self.m.close()
                pass
            pass
        self.m.close()
        return

    def adjustTrims(self, vfat, debug=False):
        """
        """
        print
        print "------------------------ TrimDAC routine ------------------------"
        print

        self.h = open("%s_VCal_%s" % (self.startTime, self.subname), 'a')
        if debug:
            for trim in [0, 16, 31]:
                print "TotVCal[%d](length = %d) = %s" % (
                    trim, len(self.TotVCal["%d" %
                                           (trim)]), self.TotVCal["%d" %
                                                                  (trim)])
                pass
            pass

        try:
            self.VCal_ref["0"] = sum(self.TotVCal["0"]) / len(
                self.TotVCal["0"])
            print "VCal_ref[0]   %d" % (self.VCal_ref["0"])
            self.VCal_ref["31"] = sum(self.TotVCal["31"]) / len(
                self.TotVCal["31"])
            print "VCal_ref[31]  %d" % (self.VCal_ref["31"])
            self.VCal_ref["avg"] = (self.VCal_ref["0"] +
                                    self.VCal_ref["31"]) / 2
            print "VCal_ref[avg] %d" % (self.VCal_ref["avg"])
            self.h.write("%s\n" % (self.TotVCal["0"]))
            self.h.write("%s\n" % (self.TotVCal["31"]))
        except:
            ex = sys.exc_info()[0]
            print "Caught exception: %s" % (ex)
            print "S-Curve did not work"
            self.h.close()  # changed from self.f.close()
            return False

        self.g = open("%s_TRIM_DAC_value_%s" % (self.startTime, self.subname),
                      'a')
        for channel in range(self.CHAN_MIN, self.CHAN_MAX):
            if self.debug and (channel > 10):
                continue
            self.adjustChannelTrims(vfat, channel, debug)
            pass

        self.h.write("%s\n" % (self.TotFoundVCal))
        # VCalList = [] ## where is this used???
        # minVcal = 0   ## where is this used???

        self.h.close()
        self.g.close()

        return True

    def adjustChannelTrims(self, vfat, channel, debug=False):
        """
        """
        TRIM_IT = 0
        print "TrimDAC Channel%d" % (channel)
        trimDAC = 16
        foundGood = False

        foundVCal = None  # this was not properly scoped previosly, where do we want to initialize it?
        while (foundGood == False):
            data_trim = self.scanVCalByVFAT(vfat,
                                            channel,
                                            trimDAC,
                                            ntrigs=self.N_EVENTS_SCURVE,
                                            debug=debug)
            if debug:
                print "First data word: 0x%08x" % (data_trim[0])
                pass
            try:
                for d in data_trim:
                    VCal = (d & 0xff000000) >> 24
                    Eff = (d & 0xffffff) / (1. * self.N_EVENTS_SCURVE)
                    if (Eff >= 0.48):
                        print "%d => %3.4f" % (VCal, Eff)
                        foundVCal = VCal
                        break
                    pass
                pass
            except:
                ex = sys.exc_info()[0]
                print "Caught exception: %s" % (ex)
                print "Error while reading the data, they will be ignored"
                continue

            if (foundVCal > self.VCal_ref["avg"] and TRIM_IT < self.MAX_TRIM_IT
                    and trimDAC < 31):
                trimDAC += 1
                TRIM_IT += 1
            elif (foundVCal < self.VCal_ref["avg"]
                  and TRIM_IT < self.MAX_TRIM_IT and trimDAC > 0):
                trimDAC -= 1
                TRIM_IT += 1
            else:
                self.g.write("%d\n" % (trimDAC))
                self.TotFoundVCal.append(foundVCal)
                self.f.write("S_CURVE_%d\n" % (channel))
                for d in data_trim:
                    self.f.write("%d\t%f\n" %
                                 ((d & 0xff000000) >> 24,
                                  (d & 0xffffff) / (1. * self.N_EVENTS_TRIM)))
                    pass
                break
            pass
        return

    def setAllTrims(self, vfat, debug=False):
        """
        """

        self.g = open("%s_TRIM_DAC_value_%s" % (self.startTime, self.subname),
                      'r')
        for channel in range(self.CHAN_MIN, self.CHAN_MAX):
            if self.debug and (channel > 10):
                continue
            trimDAC = (self.g.readline()).rstrip('\n')
            print "Setting channel %d trimDAC to %s" % (channel, trimDAC)
            setChannelRegister(self.glib,
                               self.gtx,
                               vfat,
                               channel,
                               mask=0x0,
                               pulse=0x0,
                               trim=int(trimDAC))
            pass
        self.g.close()
        return

    ########################## Main routine per VFAT ######################
    def runScanRoutine(self, vfat, debug=False):
        """
        """
        chipID = getChipID(self.glib, self.gtx, vfat)
        print "AMC%02d  OH%02d  VFAT%02d  0x%04x" % (self.slot, self.gtx, vfat,
                                                     chipID)
        print
        ########################## Setup the VFAT         ######################
        print "Setup the VFAT"
        self.setupVFAT(vfat)

        ########################## Initial threshold scan ######################
        print "Initial threshold scan"
        data_threshold = self.scanThresholdByVFAT(vfat, debug=debug)
        print "Length of returned data_threshold = %d" % (len(data_threshold))
        threshold = 0
        noise = 100 * (data_threshold[0] & 0xffffff) / (1. *
                                                        self.N_EVENTS_THRESH)
        if debug:
            print "First data word: 0x%08x" % (data_threshold[0])
            pass
        print "%d = %3.4f" % (((data_threshold[0] & 0xff000000) >> 24), noise)
        for d in range(1, len(data_threshold) - 1):
            noise = 100 * (data_threshold[d]
                           & 0xffffff) / (1. * self.N_EVENTS_THRESH)
            lastnoise = 100 * (data_threshold[d - 1]
                               & 0xffffff) / (1. * self.N_EVENTS_THRESH)
            nextnoise = 100 * (data_threshold[d + 1]
                               & 0xffffff) / (1. * self.N_EVENTS_THRESH)

            passAbs = (noise) < self.THRESH_ABS
            passLastRel = (lastnoise - noise) < self.THRESH_REL
            passNextRel = abs(noise - nextnoise) < self.THRESH_REL

            print "%d = %3.4f" % ((
                (data_threshold[d] & 0xff000000) >> 24), noise)
            if passAbs and passLastRel and passNextRel:
                # why is the threshold set to the previous value?
                threshold = (data_threshold[d] >> 24)
                setVFATThreshold(self.glib,
                                 self.gtx,
                                 vfat,
                                 vt1=(threshold),
                                 vt2=0)
                print "Threshold set to: %d" % (threshold)
                self.f.write("Threshold set to: %d\n" % (threshold))
                self.z.write("vthreshold1: %d\n" % (threshold))
                break
            pass
        # self.z.close()

        if threshold == 0 or threshold == 255:
            print "ignored"
            for d in range(0, len(data_threshold)):
                self.f.write("%d\t%f\n" %
                             ((data_threshold[d] & 0xff000000) >> 24, 100 *
                              (data_threshold[d] & 0xffffff) /
                              (1. * self.N_EVENTS_THRESH)))
                pass
            self.f.close()
            return

        for d in range(0, len(data_threshold)):
            self.f.write("%d\t%f\n" %
                         ((data_threshold[d] & 0xff000000) >> 24, 100 *
                          (data_threshold[d] & 0xffffff) /
                          (1. * self.N_EVENTS_THRESH)))
            pass

        ##################Parts of the routine require the L1A+CalPulse ######################
        startLocalT1(self.glib, self.gtx)

        ########################## Initial latency scan ######################
        if self.doLatency:
            print "Initial latency scan"

            data_latency = self.scanLatencyByVFAT(vfat, debug=debug)

            print "Length of returned data_latency = %d" % (len(data_latency))
            if not len(data_latency):
                print "data_latency is empty"
                return
            if debug:
                print "First data word: 0x%08x" % (data_latency[0])
                pass
            eff = 100 * (data_latency[0] & 0xffffff) / (1. * self.N_EVENTS_LAT)
            print "%d = %3.4f" % (((data_latency[0] & 0xff000000) >> 24), eff)
            for d in range(1, len(data_latency) - 1):
                eff = 100 * (data_latency[d] & 0xffffff) / (1. *
                                                            self.N_EVENTS_LAT)
                lasteff = 100 * (data_latency[d - 1]
                                 & 0xffffff) / (1. * self.N_EVENTS_LAT)
                nexteff = 100 * (data_latency[d + 1]
                                 & 0xffffff) / (1. * self.N_EVENTS_LAT)
                print "%d = %3.4f" % ((
                    (data_latency[d] & 0xff000000) >> 24), eff)
                if (eff) > self.LAT_ABS and (nexteff) > self.LAT_ABS and (
                        lasteff) <= self.LAT_ABS:
                    latency = (data_latency[d + 1] >> 24)
                    writeVFAT(self.glib, self.gtx, vfat, "Latency", (latency))
                    print "Latency set to: %d" % (latency)
                    self.f.write("Latency set to: %d\n" % (latency))
                    self.z.write("latency: %d\n" % (latency))
                    #if not debug:
                    break
                    #pass
                pass
            pass
        else:
            writeVFAT(self.glib, self.gtx, vfat, "Latency", (37))
            print "Latency set to: %d" % (37)
            self.f.write("Latency set to: %d\n" % (37))
            self.z.write("latency: %d\n" % (37))
            pass
        self.z.close()

        ################## Run S-Curves on all channels ######################
        print "Run S-Curves on all channels"
        self.runAllChannels(vfat, debug=debug)

        # if self.doQC3:
        #     return

        ################## Adjust the trim for each channel ######################
        print "Adjust the trim for each channel"
        if self.adjustTrims(vfat, debug=debug):

            ################# Set all the TrimDACs to the right value #################
            print "Set all the TrimDACs to the right value"
            self.setAllTrims(vfat, debug=debug)
            pass

        ########################## Final threshold scan ######################
        print "Final threshold scan"
        stopLocalT1(self.glib, self.gtx)
        self.f.write("second_threshold\n")
        data_threshold = self.scanThresholdByVFAT(vfat, debug=debug)
        if not len(data_threshold):
            print "data_threshold is empty"
            return
        if debug:
            print "First data word: 0x%08x" % (data_threshold[0])
            pass
        for d in data_threshold:
            self.f.write("%d\t%f\n" %
                         ((d & 0xff000000) >> 24, 100 * (d & 0xffffff) /
                          (1. * self.N_EVENTS_THRESH)))
            pass

        ########################## Final latency scan ######################
        if self.doLatency:
            print "Final latency scan"
            startLocalT1(self.glib, self.gtx)
            data_latency = self.scanLatencyByVFAT(vfat, debug=debug)

            print "Length of returned data_latency = %d" % (len(data_latency))
            if not len(data_latency):
                print "data_latency is empty"
                return
            if debug:
                print "First data word: 0x%08x" % (data_latency[0])
                pass
            eff = 100 * (data_latency[0] & 0xffffff) / (1. * self.N_EVENTS_LAT)
            print "%d = %3.4f" % (((data_latency[0] & 0xff000000) >> 24), eff)
            for d in range(1, len(data_latency) - 1):
                eff = 100 * (data_latency[d] & 0xffffff) / (1. *
                                                            self.N_EVENTS_LAT)
                lasteff = 100 * (data_latency[d - 1]
                                 & 0xffffff) / (1. * self.N_EVENTS_LAT)
                nexteff = 100 * (data_latency[d + 1]
                                 & 0xffffff) / (1. * self.N_EVENTS_LAT)
                print "%d = %3.4f" % ((
                    (data_latency[d] & 0xff000000) >> 24), eff)
                if (eff) > self.LAT_ABS and (nexteff) > self.LAT_ABS and (
                        lasteff) <= self.LAT_ABS:
                    writeVFAT(self.glib, self.gtx, vfat, "Latency", (d + 1))
                    print "Latency set to: %d" % (d + 1)
                    break
                pass
            pass
        else:
            pass

        self.f.close()
        self.cleanup()

        if debug:
            raw_input("enter to finish")
            pass
        ##################### Stop local T1 controller ######################
        resetLocalT1(self.glib, self.gtx)

        return
예제 #25
0
 def get_hw(self):
     uhal.setLogLevelTo(uhal.LogLevel.DEBUG)
     self.hw = uhal.getDevice("HappyDaq.udp.0", self.device_uri,
                              self.address_table_uri)
     return self.hw
예제 #26
0
def gemsupervisor(request):
  global state
  global m_AMC13manager
  global m_AMCmanager
  global verbosity
  global m_filename
  global form
  global m_monitor
  global lt

  def updateStatus():
    status = m_AMC13manager.device.getStatus()
    status.SetHTML()
    # Create pipe and dup2() the write end of it on top of stdout, saving a copy
    # of the old stdout
    out = OutputGrabber()
    out.start()
    status.Report(verbosity)
    out.stop()
    shtml = out.capturedtext
    with open("webdaq/templates/amc13status.html", "w") as text_file:
      text_file.write(shtml)
    with open("webdaq/templates/amcstatus.html", "w") as text_file:
        text_file.write(m_AMCmanager.getStatus(verbosity))

  def parkData():
#call root converter
    call_command =  os.getenv('BUILD_HOME')+'/gem-light-dqm/gemtreewriter/bin/'+os.getenv('XDAQ_OS')+'/'+os.getenv('XDAQ_PLATFORM')+'/unpacker'
    command_args = "/tmp/"+m_filename+".dat sdram"
    call([call_command+' '+command_args],shell=True)
#create dirs in tmp
    for i in range (24):
      call(["mkdir -p /tmp/dqm_hists/%s"%(i)],shell=True)
    call(["mkdir -p /tmp/dqm_hists/OtherData"],shell=True)
    call(["mkdir -p /tmp/dqm_hists/canvases"],shell=True)
#call dqm
    call_command =  os.getenv('BUILD_HOME')+'/gem-light-dqm/dqm-root/bin/'+os.getenv('XDAQ_OS')+'/'+os.getenv('XDAQ_PLATFORM')+'/dqm'
    command_args = "/tmp/"+m_filename+".raw.root"
    os.system(call_command+' '+command_args)
#call dqm printer
    call_command =  os.getenv('BUILD_HOME')+'/gem-light-dqm/dqm-root/bin/'+os.getenv('XDAQ_OS')+'/'+os.getenv('XDAQ_PLATFORM')+'/gtprinter'
    command_args = "/tmp/"+m_filename+".analyzed.root"
    os.system(call_command+' '+command_args)
#copy results to DQM display form
    #call_command = "/home/mdalchen/work/ldqm-browser/LightDQM/LightDQM/test/"
    call_command = os.getenv('LDQM_STATIC')+'/'
    # call_command += m_filename[10:15]
    # call_command += "/"
    # call_command += m_filename[:9]
    # call_command += "/"
    # call_command += "TAMU/GEB-GTX0-Long/"
    call(["mkdir -p "+call_command],shell=True)
    call(["cp -r /tmp/"+m_filename+" "+call_command],shell=True)

  if request.POST:
    if 'configure' in request.POST:
      form = ConfigForm(request.POST)
      if form.is_valid():
        amc13N = form.cleaned_data['amc13_choice']
        amc_list = form.cleaned_data['amc_list']
        amc_str = ""
        for amcN in amc_list:
          amc_str += str(amcN) + ","
        amc_str = amc_str[:-1]
        trigger_type = form.cleaned_data['trigger_type']
        if trigger_type == '1':
          lt=True
          m_monitor = True
        else:
          lt=False
          m_monitor = False
        trigger_rate = int(form.cleaned_data['trigger_rate'])
        verbosity = int(form.cleaned_data['verbosity'])
        uhal.setLogLevelTo(uhal.LogLevel.ERROR)
        #configure GLIB. Currently supports only one GLIB
        try:
          m_AMC13manager.connect(str(amc13N),verbosity)
          m_AMC13manager.configureInputs(amc_str)
          m_AMC13manager.reset()
          for amcN in amc_list:
            m_AMCmanager.connect(int(amcN))
            m_AMCmanager.reset()
            n_gtx = m_AMCmanager.activateGTX()
            print "N GTX links %s" %(n_gtx)
            # retrieve VFAT slot numberd and ChipIDs from HW
            for gtx in range(n_gtx):
              chipids = m_AMCmanager.getVFATs(gtx)
              # retrieve VFAT slot numberd and ChipIDs from DB
              vfats = VFAT.objects.all()
              # Check if the VFATs are in DB, add if not
              v_list = []
              for chip in chipids.keys():
                t_chipid = "0x%04x"%(chipids[chip])
                if t_chipid in vfats.filter(Slot=chip).values_list("ChipID", flat=True):
                  pass
                else:
                  print "Adding VFAT(ChipID = %s, Slot = %d)"%(t_chipid,chip)
                  v = VFAT(ChipID = t_chipid, Slot = chip)
                  v.save()
                v_list.append(VFAT.objects.get(ChipID = t_chipid, Slot = chip))
              #t_chamberID = 'OHv2aM'#hard code now, read from HW later when available
              t_chamberID = 'GTX-'+str(gtx) #use gtx link number now, read from HW later when available
              print "t_chamberID = %s" %(t_chamberID)
              g_list = []
              gebs = GEB.objects.filter(ChamberID=t_chamberID)
              t_flag = False
              for geb in gebs:
                if v_list == list(geb.vfats.all()):
                  t_flag = True
                  g_list.append(geb)
                  break
              if t_flag:
                pass
              else:
                print "Update DB"
                g = GEB(Type="Long",ChamberID = t_chamberID)
                g.save()
                for v in v_list:
                  g.vfats.add(v)
                  g_list.append(g)

            t_flag = False
            #t_boardID = "47-20120013"#hard code now, read from HW later when available
            t_boardID = "AMC-"+str(amcN)#hard code now, read from HW later when available
            a_list = []
            amcs = AMC.objects.filter(BoardID = t_boardID)
            for amc in amcs:
              if g_list == list(amc.gebs.all()):
                t_flag = True
                a_list.append(amc)
            if t_flag:
              pass
            else:
              print "Update DB"
              a = AMC(Type="GLIB",BoardID = t_boardID)
              a.save()
              for g in g_list:
                a.gebs.add(g)
                a_list.append(a)

          # create a new run. Some values are hard-coded for now
          runs = Run.objects.filter(Period = "2016T", Type = "bench", Station = "TAMU")
          rns = list(int(x) for x in list(runs.values_list("Number", flat=True)))
          nrs = u'%s'%(max(rns)+1)
          nrs = nrs.zfill(6)
          t_date = str(datetime.date.today())
          m_filename = "run"+str(nrs)+""+"_bench_TAMU_"+t_date
          newrun = Run(Name=m_filename, Type = "bench", Number = str(nrs), Date = datetime.date.today(), Period = "2016T", Station = "TAMU")
          newrun.save()
          for a in a_list:
            newrun.amcs.add(a)
          m_AMC13manager.configureTrigger(lt,2,1,int(trigger_rate),0)
          updateStatus()
          state = 'configured'
        except ValueError,e:
          print colors.YELLOW,e,colors.ENDC
          state = 'halted'
    elif 'halt' in request.POST:
      form = ConfigForm()
      m_AMC13manager.reset()
      state = 'halted'
    elif 'run' in request.POST:
      print "running"
      #form = ConfigForm()
      updateStatus()
      nevents = int(request.POST['nevents'])
      t = threading.Thread(target = m_AMC13manager.startDataTaking, args = ["/tmp/"+m_filename+".dat"])
      t.start()
      state = 'running'

    elif 'stop' in request.POST:
      m_AMC13manager.stopDataTaking()
      updateStatus()
      sleep(1)
      t_p = threading.Thread(target = parkData)
      t_p.start()
      state = 'configured'
    elif "monitoring" in request.POST:
      updateStatus()
예제 #27
0
#!/usr/bin/python

# This script resets the board

from __future__ import print_function

import uhal
import time
import sys
import collections

uhal.setLogLevelTo(uhal.LogLevel.ERROR)
manager = uhal.ConnectionManager("file://connections.xml")
board = manager.getDevice(sys.argv[1])
board.getClient().setTimeoutPeriod(10000)

v = board.getNode("csr.id").read()
board.dispatch()
print("Board ID:", hex(v))

board.getNode("daq.timing.csr.ctrl.rst").write(1) # Hold clk40 domain in reset
board.dispatch()

board.getNode("csr.ctrl.soft_rst").write(1) # Reset ipbus registers
board.dispatch()
예제 #28
0
def main():
    # configure logger
    global log
    log = logging.getLogger("main")
    formatter = logging.Formatter('%(name)s %(levelname)s: %(message)s')
    handler = logging.StreamHandler(sys.stdout)
    handler.setFormatter(formatter)
    log.addHandler(handler)
    log.setLevel(logging.WARNING)

    #tell uHAL to calm down.
    uhal.setLogLevelTo(uhal.LogLevel.WARNING)

    #command line
    parser = argparse.ArgumentParser(
        description="Create auto-generated files for the build system.")
    parser.add_argument("--slavesFile",
                        "-s",
                        help="YAML file storing the slave info for generation",
                        required=True)
    parser.add_argument("--addSlaveTCLPath",
                        "-t",
                        help="Path for AddSlaves.tcl",
                        required=True)
    parser.add_argument("--addressTablePath",
                        "-a",
                        help="Path for address table generation yaml",
                        required=True)
    parser.add_argument("--dtsiPath",
                        "-d",
                        help="Path for dtsi yaml",
                        required=True)
    args = parser.parse_args()

    #AddSlaves tcl file
    tclFile = open(args.addSlaveTCLPath + "/AddSlaves.tcl", "w")
    tclFile.write(
        "#================================================================================\n"
    )
    tclFile.write("#  Configure and add AXI slaves\n")
    tclFile.write("#  Auto-generated by \n")
    tclFile.write(
        "#================================================================================\n"
    )

    #dtsi yaml file
    dtsiYAMLFile = open(args.dtsiPath + "/slaves.yaml", "w")
    dtsiYAML = dict()

    #address table yaml file
    addressTableYAMLFile = open(args.addressTablePath + "/slaves.yaml", "w")
    aTableYAML = dict()

    #source slave yaml to drive the rest of the build
    slavesFile = open(args.slavesFile)
    slaves = yaml.load(slavesFile)
    for slave in slaves['AXI_SLAVES']:
        #update all the files for this slave
        LoadSlave(slave, slaves["AXI_SLAVES"][slave], tclFile, dtsiYAML,
                  aTableYAML, "")

    dtsiYAML = {"DTSI_CHUNKS": dtsiYAML}
    aTableYAML = {"UHAL_MODULES": aTableYAML}

    dtsiYAMLFile.write(
        yaml.dump(dtsiYAML, Dumper=MyDumper, default_flow_style=False))
    addressTableYAMLFile.write(
        yaml.dump(aTableYAML, Dumper=MyDumper, default_flow_style=False))
예제 #29
0
######################################################################

if __name__ == '__main__':

    if len(sys.argv) < 3:
        print "Please specify the device IP address" \
            " and the top-level address table file to use"
        sys.exit(1)

    device_ip = sys.argv[1]
    device_uri = "ipbusudp-2.0://" + device_ip + ":50001"
    address_table_name = sys.argv[2]
    address_table_uri = "file://" + address_table_name

    uhal.setLogLevelTo(uhal.LogLevel.WARNING)
    hw = uhal.getDevice("dummy", device_uri, address_table_uri)

    reg_name_base = "sysmon."
    regs = ["temp", "vccint", "vccaux", "vrefp", "vrefn", "vccbram"]
    max_len = max([len(i) for i in regs])

    print "IPBus SysMon/XADC demo:"
    for reg_name_spec in regs:
        reg_name = reg_name_base + reg_name_spec
        node = hw.getNode(reg_name)
        val_raw = node.read()
        hw.dispatch()

        # NOTE: Yes, flexible but ugly.
        val = val_raw.value()
예제 #30
0
    def __init__(self, dev_name, man_file):
        uhal.setLogLevelTo(uhal.LogLevel.NOTICE
                           )  ## Get rid of initial flood of IPBUS messages
        self.dev_name = dev_name
        self.manager = uhal.ConnectionManager(man_file)
        self.hw = self.manager.getDevice(self.dev_name)

        #self.fwVersion = self.hw.getNode("version").read()
        #self.hw.dispatch()
        #print "--", self.dev_name, "FIRMWARE VERSION= " , hex(self.fwVersion)

        # Instantiate a I2C core to configure components
        #self.i2c_master= I2CCore(self.hw, 10, 5, "i2c_master", None)
        self.i2c_master = I2CCore(self.hw, 10, 5, "io.i2c", None)

        # Instantiate a secondary I2C core for SFP cage (not working yet)
        #self.i2c_secondary= I2CCore(self.hw, 10, 5, "io.usfp_i2c", None)

        # Enable the I2C interface on enclustra
        enableCore = True  #Only need to run this once, after power-up
        self._enableCore()

        # Instantiate EEPROM
        self.zeEEPROM = E24AA025E48T(self.i2c_master, 0x57)

        # Instantiate clock chip
        self.zeClock = si5345(self.i2c_master, 0x68)
        res = self.zeClock.getDeviceVersion()
        self.zeClock.checkDesignID()

        # Instantiate expander for the equalizers (IC28)
        self.exp_EQ = PCA9539PW(self.i2c_master, 0x74)
        self.exp_EQ.setInvertReg(0, 0x00)  # 0= normal
        self.exp_EQ.setIOReg(0, 0x00)  # 0= output <<<<<<<<<<<<<<<<<<<
        self.exp_EQ.setInvertReg(1, 0x00)  # 0= normal
        self.exp_EQ.setIOReg(1, 0x00)  # 0= output <<<<<<<<<<<<<<<<<<<

        # Instantiate expander for SFP signals (IC29)
        self.exp_SFP = PCA9539PW(self.i2c_master, 0x75)
        self.exp_SFP.setInvertReg(0, 0x00)  # 0= normal
        self.exp_SFP.setIOReg(0, 0x00)  # 0= output <<<<<<<<<<<<<<<<<<<
        self.exp_SFP.setInvertReg(1, 0x00)  # 0= normal
        self.exp_SFP.setIOReg(1, 0xFF)  # FF= input <<<<<<<<<<<<<<<<<<<

        # Instantiate expander for LED control (IC27)
        self.exp_LED = PCA9539PW(self.i2c_master, 0x76)
        self.exp_LED.setInvertReg(0, 0x00)  # 0= normal
        self.exp_LED.setIOReg(0, 0x00)  # 0= output (LED) <<<<<<<<<<<<<<<<<<<
        self.exp_LED.setInvertReg(1, 0x00)  # 0= normal
        self.exp_LED.setIOReg(1, 0x00)  # 0= output <<<<<<<<<<<<<<<<<<<

        # Instantiate I2C multiplexer
        self.mux_I2C = PCA9548ADW(self.i2c_master, 0x73)

        # Instantiate a generic SFP transceiver for one of the 8 downstream
        self.SFP_ds = SFPI2C(self.i2c_master, 0x50)

        # Instantiate CDR for upstream and multiplexer
        self.cdr_UPS = ADN2814ACPZ(self.i2c_master, 0x40)
        self.cdr_MUX = ADN2814ACPZ(self.i2c_master, 0x60)

        #Instantiate Display
        doDisplaytest = False
        if doDisplaytest:
            self.DISP = LCD09052(self.i2c_master, 0x3A)  #3A
            self.DISP.clear()
            self.DISP.test()