#!/usr/bin/env python26
"""
VERSION 3.1.7
It prints the configuration stream of 51 32-bit words to the terminal based
on the configuration setup on the screen of tab 1. It writes these words to
the appropriate vmm2 registers. It cycles the data in the registers to vmm2
as a 1616 bit stream.
This version uses file://glibConnection.xml (192.168.0.10:50001). The registers
are identified in glibAddr.xml.
This version is able to read the DAQ from two FIFOs. The 38-bit data is
displayed as:
flag, threshold, channel address, amplitude, time, and BCid.
It is also written to a file.
The data displayed in the terminal will eventually be displayed in a gtk.TextView
on one of the tabs. Histograms will also be displayed, probably using pyroot.
-- added the ability to edit user_ipb_vmm_cfg_reg63 (0x4000_00FF) on tab 3
-- also added the ability to read and write to the FIFO38 ctrl/status reg on tab 3
by Charlie Armijo and James Wymer.
Physics Department
University of Arizona
"""
import pygtk
pygtk.require('2.0')
import gtk
from array import *
#### On PCROD0 use from Numpy import *
import numpy as np
#from Numeric import *
from struct import *
import gobject
#from PyChipsUser import *
from subprocess import call
from time import sleep
import sys
import os
import uhal
import time
import math
import binstr
#########################
#########################
##### channel class #####
#########################
#########################
class channel:
def __init__(self, chan_num):
self.chan_num = chan_num
self.chan_obj_list = []
def add_object(self, object):
self.chan_obj_list.append(object)
#####################
#####################
##### vmm class #####
#####################
#####################
class Vmm:
msg = np.zeros((67), dtype=np.uint32)
read_msg = np.zeros((67), dtype=np.uint32)
chan = np.zeros((24), dtype=int)
globalreg = np.zeros((96), dtype=int)
#reg = [[chan] for i in range(65)]
reg = np.zeros((64, 24), dtype=int)
chnlReg = np.zeros((51), dtype=int)
dummyReg = np.zeros((32), dtype=int)
buf = gtk.TextBuffer(table=None)
byteint = np.zeros((51), dtype=np.uint32)
testreg1 = 0
testreg2 = 0
testreg3 = 0
check_button_SP_qs = gtk.CheckButton()
check_button_SC_qs = gtk.CheckButton()
check_button_SL_qs = gtk.CheckButton()
check_button_ST_qs = gtk.CheckButton()
check_button_SM_qs = gtk.CheckButton()
check_button_SD_qs = gtk.CheckButton()
button_SMX_qs = gtk.CheckButton()
toggle_button_SP = gtk.ToggleButton(label="n")
check_button_SC = gtk.CheckButton()
check_button_SL = gtk.CheckButton()
check_button_ST = gtk.CheckButton()
check_button_SM = gtk.CheckButton()
combo_SD = gtk.combo_box_new_text()
button_SMX = gtk.CheckButton()
"""
# hw = uhal.getDevice( "glib.udp.04" , "ipbusudp-2.0://192.168.0.10:50001" "file://glibAddr.xml" )
# can also try ============
# chtcp-1.3 : Hardware access via the Control Hub, using IPbus version 1.3
# chtcp-2.0 : Hardware access via the Control Hub, using IPbus version 2.0
# chtcp-2.0-bigendian : Hardware access via the Control Hub, using IPbus version 2.0, with the big-endian hack
# ipbustcp-1.3 : Direct access to hardware via TCP, using IPbus version 1.3
# ipbustcp-2.0 : Direct access to hardware via TCP, using IPbus version 2.0
# ipbustcp-2.0-bigendian : Direct access to hardware via TCP, using IPbus version 2.0, with the big-endian hack
# ipbusudp-1.3 : Direct access to hardware via UDP, using IPbus version 1.3
# ipbusudp-2.0 : Direct access to hardware via UDP, using IPbus version 2.0
# ipbusudp-2.0-bigendian : Direct access to hardware via UDP, using IPbus version 2.0, with the big-endian hack
"""
manager = uhal.ConnectionManager("file://glibConnection.xml")
hw = manager.getDevice("glib.udp.04")
# Grab device's id, or print it to screen
device_id = hw.id()
print "Connected to:"
print hw
# Grab the device's URI
device_uri = hw.uri()
print device_uri
print
def destroy(self,widget,data=None):
print "Goodbye from VMM2!"
gtk.main_quit()
def on_erro(self, widget, msg):
md = gtk.MessageDialog(None,
gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK, msg)
md.set_title("ERROR")
md.run()
md.destroy()
def write_vmmConfigRegisters(self,widget):
"""create full config list"""
self.entry_SDP_.grab_focus()
self.entry_SDT.grab_focus()
self.button_write.grab_focus()
reglist = list(self.reg.flatten())
globalreglist = list(self.globalreg.flatten())
fullreg = reglist[::-1] + globalreglist[::-1]
chars = []
n=0
reglist = reglist[::-1]
for b in range(51):
self.byteint[b] = 0
bytelist = fullreg[b*32:(b+1)*32]
n = n+1
dummyReg = bytelist[::-1]
#string = "A" + str(b)
for bit in range(32):
self.byteint[b] += int(dummyReg[bit])*pow(2, 31-bit)
try:
for b in range(51):
string = "A" + str(b)
self.hw.getNode("CFG").getNode(string).write(int(self.byteint[b]))
print "0x%0.8X " % self.byteint[b] + " " + string
self.hw.dispatch()
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nStatus Reg 1 not hexadecimal."
self.on_erro(widget, myMsg)
"""
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
"""
print "\nWrote to Config Registers\n"
def read_reg(self,widget):
try:
# IPbus Transaction
REG = self.hw.getNode("CFG").getNode("A62").read()
#CFG_REG0 = self.hw.getNode("CFG").getNode("A0").read()
#CFG_REG1 = self.hw.getNode("CFG").getNode("A1").read()
#CFG_REG2 = self.hw.getNode("CFG").getNode("A2").read()
#CFG_REG3 = self.hw.getNode("CFG").getNode("A3").read()
#CFG_REG4 = self.hw.getNode("CFG").getNode("A4").read()
#CFG_REG5 = self.hw.getNode("CFG").getNode("A5").read()
self.hw.dispatch()
print"|==========================================|"
print "Read the Config Registers:"
print "Configuration Status REG =" + str(hex(REG))
#print "CFG_REG0 =", hex(CFG_REG0)
#print "CFG_REG1 =", hex(CFG_REG1)
#print "CFG_REG2 =", hex(CFG_REG2)
#print "CFG_REG3 =", hex(CFG_REG3)
#print "CFG_REG4 =", hex(CFG_REG4)
#print "CFG_REG5 =", hex(CFG_REG5)
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nStatus Reg 1 not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def reset_params(self, widget):
print "Resetting Parameters"
#for i in range(64):
#self.check_button_SC1 = gtk.CheckButton()
#self.check_button_SL1 = gtk.CheckButton()
#self.check_button_ST1 = gtk.CheckButton()
#self.check_button_SM1 = gtk.CheckButton()
name = "SC" + str(1)
self.name.set_active(false)
# name = "self.check_buttonSL" + str(i)
# name.set_active()
for i in range(1615):
self.msg[i] = 0
print self.msg
def uInt32HexStr(self, uInt32):
"""Return a string of a 32-bit unsigned integer without any minus signs, or other stupidity.
"""
littleEnd = uInt32 & 0xffffffff
result = "%(#1)08x" % { "#1" : littleEnd }
return result
def empty_callback(self, widget, data=None):
""" This Function does nothing, but it is very quick and effective
"""
def cycle_config(self, widget):
try:
# This uses glibAddr.xml and uHAL to
# load the config bitstream from the glib
# kj changes back to 1
for i in range(1):
initialState = self.hw.getNode("CFG").getNode("A63").read()
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.dispatch()
clearState = self.hw.getNode("CFG").getNode("A63").read()
# kj change from 1 to 0
self.hw.getNode("CFG").getNode("A63").write(0x1)
self.hw.dispatch()
time.sleep(.1)
firstState = self.hw.getNode("CFG").getNode("A63").read()
self.hw.getNode("CFG").getNode("A63").write(0x0)
midState = self.hw.getNode("CFG").getNode("A63").read()
self.hw.getNode("CFG").getNode("A63").write(0x2)
self.hw.dispatch()
time.sleep(.1)
secondState = self.hw.getNode("CFG").getNode("A63").read()
self.hw.getNode("CFG").getNode("A63").write(0x0)
finalState = self.hw.getNode("CFG").getNode("A63").read()
self.hw.dispatch()
print "\nWrote cfg to VMM2"
# print i for use when we determine how long to wait between loops
print "Initial State = 0x%0.8X" % initialState
print "Clear State = 0x%0.8X" % clearState
print "First State = 0x%0.8X" % firstState
print "Mid State = 0x%0.8X" % midState
print "2nd State = 0x%0.8X" % secondState
print "Final State = 0x%0.8X" % finalState
cfg_status = self.hw.getNode("CFG").getNode("A62").read()
cfg_in_51 = self.hw.getNode("CFG").getNode("A50").read()
cfg_in_50 = self.hw.getNode("CFG").getNode("A49").read()
cfg_in_0 = self.hw.getNode("CFG").getNode("A0").read()
cfg_in_1 = self.hw.getNode("CFG").getNode("A1").read()
self.hw.dispatch()
print "cfg status = 0x%0.8X" % cfg_status
print "cfg_in_51 = 0x%0.8X" % cfg_in_51
print "cfg_in_50 = 0x%0.8X" % cfg_in_50
print "cfg_in_0 = 0x%0.8X" % cfg_in_0
print "cfg_in_1 = 0x%0.8X" % cfg_in_1
print "\n"
#time.sleep(1) time between config commands
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def print_config(self, widget):
"""create and print full config list"""
self.entry_SDP_.grab_focus() # gets data for
self.entry_SDT.grab_focus()
self.button_print_config.grab_focus()
reglist = list(self.reg.flatten())
globalreglist = list(self.globalreg.flatten())
fullreg = reglist[::-1] + globalreglist[::-1]
#self.buf = []
print "\n\nSTRING\n\n"
n=0
reglist = reglist[::-1]
try:
for b in range(51):
bytelist = fullreg[b*32:(b+1)*32]
byteint = 0
n = n+1
dummyReg = bytelist[::-1]
for bit in range(32):
byteint += int(dummyReg[bit])*pow(2, 31-bit)
byte = bin(byteint)
byteword = np.uint32(byteint)
self.chnlReg[b] = byteword
#print hex(self.chnlReg[b])
print "0x%0.8X " % byteword + str(n)
#self.buf = print "0x%0.8X " % byteword + str(n)
#self.tv.insert(self.buf)
except IOError as e:
myMsg = "I/O Error Reading Ctrl Reg 3:\n{1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except:
print "Unexpected Error Reading Ctrl Reg 3:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
print "String to be loaded into config registers\n\n"
"""
def read_config_VMM_reg(self, widget):
"""
"""Reading the VMM2 registers
glib = ChipsBusUdp(self.glibAddrTable, self.IP_ADDR, 50001)
print
print "---===> Reading the VMM2 Registers <===---"
glib.write("mys21", 0x00000000)
print "reading from 0x80000021: ", np.uint32HexStr(glib.read("mys21"))
glib.write("mys21", 0x0000A000)
print "reading from 0x80000021: ", np.uint32HexStr(glib.read("mys21"))
self.read_reg(widget)
"""
def run_daq_RO(self, widget):
# Runs the DAQ Readout
try:
# This uses glibAddr.xml and uHAL to
# load the config bitstream from the glib
#self.hw.getNode("DAQ").getNode("A0").getNode("B5").write(0x1) #
mystatus = self.hw.getNode("DAQ").getNode("A0").read()
#self.hw.getNode("CFG").getNode("A63").write(0x70) # ena='1' cktk=enable cktp='1'
Config = self.hw.getNode("CFG").getNode("A63").read()
self.hw.dispatch()
print "FIFO status =" + str(hex(mystatus)) + " pulser reg =" + str(hex(Config))
odd = ""
myRange = 2046 # depends on depth of FIFO38
FULL = 0
for i in range(myRange):
x = self.hw.getNode("DAQ").getNode("A0").read()
self.hw.dispatch()
if x > 3:
FULL = FULL + 1
#print "FIFO status=" + str(x)
if (x>0 and x<4):
#sleep(0.1)
Config = self.hw.getNode("CFG").getNode("A63").read()
self.hw.dispatch()
#print "FIFO38 empty " + str(i) + " Config reg =" + str(hex(Config))
else:
#
# We set the FIFO in read mode
self.hw.getNode("DAQ").getNode("A0").write(0x20)
# We read the lower 32 of 38 bits
A = self.hw.getNode("DAQ").getNode("A1").read()
# We read the upper bits
B = self.hw.getNode("DAQ").getNode("A2").read()
# We set the FIFO back to write mode
self.hw.getNode("DAQ").getNode("A0").write(0x0)
self.hw.dispatch()
low = int(A) # convert to int from "ValWord"
high = int(B)
high = high * pow(2,32) # move to the proper position
fifo38 = high + low
#print fifo38
if fifo38<4:
continue
mydata = fifo38 #print str(i) +": 38FIFO=" + str(hex(fifo38))
# fifo38 = fifo38 >> 6
fifo38 = fifo38 >> 2 # get rid of first 2 bit data0 and data1 (threshold)
addr = (fifo38 & 63) + 1 # get channel number as on GUI
fifo38 = fifo38 >> 6 # get rid of address
amp = fifo38 & 1023 # get amplitude
if (amp & 15) == 0: # are the lower 4 bit zeros? if so, tag.
odd = " ****"
else:
odd = ""
fifo38 = fifo38 >> 10
timing = fifo38 & 255
fifo38 = fifo38 >> 8
BCid = int(fifo38 & 4095) # next change from gray code to int
BCid2 = binstr.int_to_b(BCid,16)
myBCid = binstr.b_gray_to_bin(BCid2)
myIntBCid = binstr.b_to_int(myBCid)
# This should give the correct BCid
print str(i) + ": 38FIFO=" + str(hex(mydata)) + ", addr=" + str(addr) + ", amp="+str(amp)+ \
", time="+str(timing) + ", BCid= " + str(myIntBCid) + odd
#with open('Vmm2TestAll.dat', 'a') as myfile: # all data
# myfile.write(str(int(addr))+'\t'+ str(int(amp))+'\t'+ str(int(timing))+'\t'+ str(myIntBCid) +'\n')
if odd=="": # only untagged data
with open('Vmm2Test.dat', 'a') as myfile:
myfile.write(str(int(addr))+'\t'+ str(int(amp))+'\t'+ str(int(timing))+'\t'+ str(myIntBCid) +'\n')
print "Attempted to read FIFO38 " + str(myRange) +" times."
if FULL > 0:
print "FIFO38 was full " + str(FULL) + " times!"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
#except:
# print "Unexpected Error: ", sys.exc_info()[0]
# self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def reset_CLKs(self, widget):
print "\nRunning the clocks to acquire data"
try:
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.getNode("CFG").getNode("A63").write(0x50)
self.hw.getNode("CFG").getNode("A63").write(0x70)
self.hw.dispatch()
time.sleep(.5) #allow to fill FIFO with data
# then stop before fifo overflows.
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.dispatch()# enable token clk
print "Wrote 0x0, 0x8, 0x0, 0x30 to 0x70"
print "acq_rst, then ena='1' and cktp=run, then cktk= enable\n"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
# commenting this out allows more error info to be printed
#except:
# print "Unexpected Error: ", sys.exc_info()[0]
# self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def reset_acq(self, widget):
print "\nRunning Acquistion Reset"
try:
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.getNode("CFG").getNode("A63").write(0x8)
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.dispatch()
print "Wrote 0x0, 0x8 and 0x0 to config register 0x4000_00FF"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def reset_global(self, widget):
print "Running VMM emulator..." #"\nRunning Global Reset"
try:
# This uses glibAddr.xml and uHAL to
## reset the data fifos and global reset
self.hw.getNode("DAQ").getNode("A0").write(0x0)
self.hw.getNode("DAQ").getNode("A3").write(0x0)
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.getNode("DAQ").getNode("A0").write(0x8)
self.hw.getNode("DAQ").getNode("A3").write(0x1)
self.hw.getNode("CFG").getNode("A63").write(0x4)
# kj self.hw.dispatch()
# kj time.sleep(.1) # give it some time to finish the reset
self.hw.getNode("DAQ").getNode("A0").write(0x0)
self.hw.getNode("DAQ").getNode("A3").write(0x0)
self.hw.getNode("CFG").getNode("A63").write(0x0)
self.hw.dispatch()
print "Wrote global reset to CFG REG and"
print "reset the data 38 and 12 FIFOs"
print "gbl_rst complete\n"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
#######################################################
################## ###################
################## CHANNELS ###################
################## COMMANDS ###################
################## ###################
#######################################################
##### input charge polarity #####
def SP_callback(self, widget, data=None):
SP = self.reg[data-1][0]
if widget.get_active():
### toggle button is down ###
if SP == 0:
self.reg[data-1][0] = 1
widget.set_label("p")
else:
### toggle button is up ###
if SP > 0:
self.reg[data-1][0] = 0
widget.set_label("n")
##### large sensor capacitance mode #####
def SC_callback(self, widget, data=None):
SC = self.reg[data-1][1]
if widget.get_active():
### button is checked ###
if SC == 0:
self.reg[data-1][1] = 1
else:
### button is not checked ###
if SC > 0:
self.reg[data-1][1] = 0
##### leakage current disable #####
def SL_callback(self, widget, data=None):
SL = self.reg[data-1][2]
if widget.get_active():
### button is checked ###
if SL == 0:
self.reg[data-1][2] = 1
else:
### button is not checked ###
if SL > 0:
self.reg[data-1][2] = 0
##### test capacitor enable #####
def ST_callback(self, widget, data=None):
ST = self.reg[data-1][3]
if widget.get_active():
### button is checked ###
if ST == 0:
self.msg[data-1] = self.msg[data-1] + np.uint32(0x0008)
self.reg[data-1][3] = 1
else:
### button is not checked ###
if ST > 0:
self.msg[data-1] = self.msg[data-1] - np.uint32(0x0008)
self.reg[data-1][3] = 0
##### mask enable #####
def SM_callback(self, widget, data=None):
SM = self.reg[data-1][4]
if widget.get_active():
### button is checked ###
if SM == 0:
self.msg[data-1] = self.msg[data-1] + np.uint32(0x0010)
self.reg[data-1][4] = 1
else:
### button is not checked ###
if SM > 0:
self.msg[data-1] = self.msg[data-1] - np.uint32(0x0010)
self.reg[data-1][4] = 0
##### threshold DAC #####
def get_SD_value(self, widget, data=None):
active = widget.get_active()
if active < 0:
return None
else:
SD_value = active
self.msg[data-1] = np.uint32(0xFE1F) & self.msg[data-1]
### convert value to list of binary digits ###
SD_value = '{0:04b}'.format(SD_value)
SD_list = list(SD_value)
SD_list = map(int, SD_value)
### add new value to register ###
self.msg[data-1] = np.uint32(SD_value) ^ self.msg[data-1]
for i in range(4):
self.reg[data-1][i+5] = SD_list[i]
##### channel monitor mode #####
def SMX_callback(self, widget, data=None):
SMX = self.reg[data-1][9]
if widget.get_active():
### button is checked ###
if SMX == 0:
self.reg[data-1][9] = 1
else:
### button is not checked ###
if SMX > 0:
self.reg[data-1][9] = 0
##### 10-bit ADC #####
def get_SZ10b_value(self, widget, data=None):
active = widget.get_active()
if active < 0:
return None
else:
SZ10b = active
### convert value to list of binary digits ###
SZ10b = '{0:05b}'.format(SZ10b)
SZ10b_list = list(SZ10b)
SZ10b_list = map(int, SZ10b)
### add new value to register ###
for i in range(5):
self.reg[data-1][i+10] = SZ10b_list[i]
##### 8-bit ADC #####
def get_SZ8b_value(self, widget, data=None):
active = widget.get_active()
if active < 0:
return None
else:
SZ8b = active
### convert value to list of binary digits ###
SZ8b = '{0:04b}'.format(SZ8b)
SZ8b_list = list(SZ8b)
SZ8b_list = map(int, SZ8b)
### add new value to register ###
for i in range(4):
self.reg[data-1][i+15] = SZ8b_list[i]
##### 6-bit ADC #####
def get_SZ6b_value(self, widget, data=None):
active = widget.get_active()
if active < 0:
return None
else:
SZ6b = active
### convert value to list of binary digits ###
SZ6b = '{0:03b}'.format(SZ6b)
SZ6b_list = list(SZ6b)
SZ6b_list = map(int, SZ6b)
### add new value to register ###
for i in range(3):
self.reg[data-1][i+19] = SZ6b_list[i]
###############################################################
##################### ########################
##################### GLOBAL ########################
##################### COMMANDS ########################
##################### ########################
###############################################################
def quick_set(self, widget):
if check_button_ST_qs.get_active():
if check_button_ST.get_active():
check_button_ST1.set_active(True)
self.msg[data-1] = self.msg[data-1] | np.uint32(0x0008)
check_button_ST1.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse("green"))
else:
check_button_ST1.set_active(False)
self.msg[data-1] = self.msg[data-1] & np.uint32(0x0008)
check_button_ST1.modify_base(gtk.STATE_NORMAL, gtk.gdk.color_parse("white"))
"""
def get_IPaddr_value(self, widget):
active = widget.get_active()
if active < 0:
return None
else:
ipaddr = active
self.IP_ADDR = "192.168.0.10" + str(ipaddr)
print "IP Address =", self.IP_ADDR
"""
##### input charge polarity #####
def glob_SPG_callback(self, widget, data=None):
SPG = self.globalreg[16]
if widget.get_active():
### button is checked ###
if SPG == 0:
self.globalreg[16] = 1
else:
### button is not checked ###
if SPG > 0:
self.globalreg[16] = 0
##### disable at peak #####
def glob_SDPeak_callback(self, widget, data=None):
SDP = self.globalreg[17]
if widget.get_active():
### button is checked ###
if SDP == 0:
self.globalreg[17] = 1
else:
### button is not checked ###
if SDP > 0:
self.globalreg[17] = 0
##### route analog monitor to pdo output #####
def glob_SBMX_callback(self, widget, data=None):
SBMX = self.globalreg[18]
if widget.get_active():
### button is checked ###
if SBMX == 0:
self.globalreg[18] = 1
else:
### button is not checked ###
if SBMX > 0:
self.globalreg[18] = 0
##### analog output buffers enable tdo #####
def glob_SBFT_callback(self, widget, data=None):
SBFT = self.globalreg[19]
if widget.get_active():
### button is checked ###
if SBFT == 0:
self.globalreg[19] = 1
else:
### button is not checked ###
if SBFT > 0:
self.globalreg[19] = 0
##### analog output buffers enable pdo #####
def glob_SBFP_callback(self, widget, data=None):
SBFP = self.globalreg[20]
if widget.get_active():
### button is checked ###
if SBFP == 0:
self.globalreg[20] = 1
else:
### button is not checked ###
if SBFP > 0:
self.globalreg[20] = 0
##### analog output buffers enable mo #####
def glob_SBFM_callback(self, widget, data=None):
SBFM = self.globalreg[21]
if widget.get_active():
### button is checked ###
if SBFM == 0:
self.globalreg[21] = 1
else:
### button is not checked ###
if SBFM > 0:
self.globalreg[21] = 0
##### leakage current disable #####
def glob_SLG_callback(self, widget, data=None):
SLG = self.globalreg[22]
if widget.get_active():
### button is checked ###
if SLG == 0:
self.globalreg[22] = 1
else:
### button is not checked ###
if SLG > 0:
self.globalreg[22] = 0
##### monitor multiplexing #####
def glob_SM_value(self, widget):
active = widget.get_active()
if active < 0:
return None
else:
SM = active
### convert value to list of binary digits ###
SM = '{0:06b}'.format(SM)
SM_list = list(SM)
SM_list = map(int, SM)
### add new value to register ###
for i in range(5,-1,-1):
self.globalreg[i+23] = SM_list[i]
##### monitor multiplexing enable #####
def glob_SCMX_callback(self, widget, data=None):
SCMX = self.globalreg[29]
if widget.get_active():
### button is checked ###
if SCMX == 0:
self.globalreg[29] = 1
else:
### button is not checked ###
if SCMX > 0:
self.globalreg[29] = 0
##### ART enable #####
def glob_SFA_callback(self, widget, data=None):
SFA = self.globalreg[30]
if widget.get_active():
### button is checked ###
if SFA == 0:
self.globalreg[30] = 1
else:
### button is not checked ###
if SFA > 0:
self.globalreg[30] = 0
##### ART mode #####
def glob_SFAM_value(self, widget, data=None):
SFAM = self.globalreg[31]
if widget.get_active():
### 2nd option is selected ###
if SFAM == 0:
self.globalreg[31] = 1
else:
### 1st option is selected ###
if SFAM > 0:
self.globalreg[31] = 0
##### peaking time #####
def glob_ST_value(self, widget):
active = widget.get_active()
if active < 0:
return None
else:
ST = active
### convert value to list of binary digits ###
ST = '{0:02b}'.format(ST)
ST_list = list(ST)
ST_list = map(int, ST)
### add new value to register ###
for i in range(1,-1,-1):
self.globalreg[i+32] = ST_list[i]
##### UNKNOWN #####
def glob_SFM_callback(self, widget, data=None):
SFM = self.globalreg[34]
if widget.get_active():
### button is checked ###
if SFM == 0:
self.globalreg[34] = 1
else:
### button is not checked ###
if SFM > 0:
self.globalreg[34] = 0
##### gain #####
def glob_SG_value(self, widget):
active = widget.get_active()
if active < 0:
return None
else:
SG = active
### convert value to list of binary digits ###
SG = '{0:03b}'.format(SG)
SG_list = list(SG)
SG_list = map(int, SG)
### add new value to register ###
for i in range(2,-1,-1):
self.globalreg[i+35] = SG_list[i]
##### neighbor triggering enable #####
def glob_SNG_callback(self, widget, data=None):
SNG = self.globalreg[38]
if widget.get_active():
### button is checked ###
if SNG == 0:
self.globalreg[38] = 1
else:
### button is not checked ###
if SNG > 0:
self.globalreg[38] = 0
##### timing outputs control #####
def glob_STOT_value(self, widget, data=None):
STOT = self.globalreg[39]
if widget.get_active():
### button is checked ###
if STOT == 0:
self.globalreg[39] = 1
else:
### button is not checked ###
if STOT > 0:
self.globalreg[39] = 0
##### timing outputs enable #####
def glob_STTT_callback(self, widget, data=None):
STTT = self.globalreg[40]
if widget.get_active():
### button is checked ###
if STTT == 0:
self.globalreg[40] = 1
else:
### button is not checked ###
if STTT > 0:
self.globalreg[40] = 0
##### sub-hysteresis discrimination enable #####
def glob_SSH_callback(self, widget, data=None):
SSH = self.globalreg[41]
if widget.get_active():
### button is checked ###
if SSH == 0:
self.globalreg[41] = 1
else:
### button is not checked ###
if SSH > 0:
self.globalreg[41] = 0
##### TAC slope adjustment #####
def glob_STC_value(self,widget):
active = widget.get_active()
if active < 0:
return None
else:
STC = active
### convert value to list of binary digits ###
STC = '{0:02b}'.format(STC)
STC_list = list(STC)
STC_list = map(int, STC)
### add new value to register ###
for i in range(1,-1,-1):
self.globalreg[i+42] = STC_list[i]
##### course threshold DAC #####
def glob_SDT_entry(self, widget, entry):
try:
entry = widget.get_text()
value = int(entry)
except ValueError:
print "SDT value must be a decimal number"
print
return None
if (value < 0) or (1023 < value):
print "SDT value out of range"
print
return None
else:
SDT = value
### convert value to list of binary digits ###
SDT = '{0:010b}'.format(SDT)
SDT_list = list(SDT)
SDT_list = map(int, SDT)
### add new value to register ###
for i in range(9,-1,-1):
self.globalreg[i+44] = SDT_list[i] ## 28
##### test pulse DAC #####
def glob_SDP_entry(self,widget,entry):
try:
entry = widget.get_text()
value = int(entry)
except ValueError:
print "SDP value must be a decimal number"
print
return None
if (value < 0) or (1023 < value):
print "SDP value out of range"
print
return None
else:
SDP = value
### convert value to list of binary digits ###
SDP = '{0:010b}'.format(SDP)
SDP_list = list(SDP)
SDP_list = map(int, SDP)
### add new value to register ###
for i in range(9,-1,-1):
self.globalreg[i+54] = SDP_list[i] ## 38
##### 10-bit ADC conversion time #####
def glob_SC10b_value(self,widget):
active = widget.get_active()
if active < 0:
return None
else:
SC10b = active
### convert value to list of binary digits ###
SC10b = '{0:02b}'.format(SC10b)
SC10b_list = list(SC10b)
SC10b_list = map(int, SC10b)
### add new value to register ###
# reverse bit order
for i in range(2):
self.globalreg[65-i] = SC10b_list[i]
##### 8-bit ADC conversion time #####
def glob_SC8b_value(self,widget):
active = widget.get_active()
if active < 0:
return None
else:
SC8b = active
### convert value to list of binary digits ###
SC8b = '{0:02b}'.format(SC8b)
SC8b_list = list(SC8b)
SC8b_list = map(int, SC8b)
### add new value to register ###
# reverse bit order
for i in range(2):
self.globalreg[67-i] = SC8b_list[i]
##### 6-bit ADC conversion time #####
def glob_SC6b_value(self,widget):
active = widget.get_active()
if active < 0:
return None
else:
SC6b = active
### convert value to list of binary digits ###
SC6b = '{0:03b}'.format(SC6b)
SC6b_list = list(SC6b)
SC6b_list = map(int, SC6b)
### add new value to register ###
# reverse bit order
for i in range(3):
self.globalreg[70-i] = SC6b_list[i]
##### 8-bit ADC conversion mode #####
def glob_S8b_callback(self,widget, data=None):
S8b = self.globalreg[71]
if widget.get_active():
### button is checked ###
if S8b == 0:
self.globalreg[71] = 1
else:
### button is not checked ###
if S8b > 0:
self.globalreg[71] = 0
##### 6-bit ADC conversion enable #####
def glob_S6b_callback(self, widget, data=None):
S6b = self.globalreg[72]
if widget.get_active():
### button is checked ###
if S6b == 0:
self.globalreg[72] = 1
else:
### button is not checked ###
if S6b > 0:
self.globalreg[72] = 0
##### ADCs enable #####
def glob_SPDC_callback(self, widget, data=None):
SPDC = self.globalreg[73]
if widget.get_active():
### button is checked ###
if SPDC == 0:
self.globalreg[73] = 1
else:
### button is not checked ###
if SPDC > 0:
self.globalreg[73] = 0
##### dual clock edge serialized data enable #####
def glob_SDCKS_callback(self, widget, data=None):
SDCKS = self.globalreg[74]
if widget.get_active():
### button is checked ###
if SDCKS == 0:
self.globalreg[74] = 1
else:
### button is not checked ###
if SDCKS > 0:
self.globalreg[74] = 0
##### dual clock edge serialized ART enable #####
def glob_SDCKA_callback(self, widget, data=None):
SDCKA = self.globalreg[75]
if widget.get_active():
### button is checked ###
if SDCKA == 0:
self.globalreg[75] = 1
else:
### button is not checked ###
if SDCKA > 0:
self.globalreg[75] = 0
##### dual clock edge serialized 6-bit enable #####
def glob_SDCK6b_callback(self, widget, data=None):
SDCK6b = self.globalreg[76]
if widget.get_active():
### button is checked ###
if SDCK6b == 0:
self.globalreg[76] = 1
else:
### button is not checked ###
if SDCK6b > 0:
self.globalreg[76] = 0
##### tristates analog outputs with token, used in analog mode #####
def glob_SDRV_callback(self, widget, data=None):
SDRV = self.globalreg[77]
if widget.get_active():
### button is checked ###
if SDRV == 0:
self.globalreg[77] = 1
else:
### button is not checked ###
if SDRV > 0:
self.globalreg[77] = 0
##### timing outputs control 2 #####
def glob_STPP_callback(self, widget, data=None):
STPP = self.globalreg[78]
if widget.get_active():
### button is checked ###
if STPP == 0:
self.globalreg[78] = 1
else:
### button is not checked ###
if STPP > 0:
self.globalreg[78] = 0
def myTest(self, widget, data=None):
print "Hello"
#########################################
########### page 3 commands #############
#########################################
def tobits(self, s):
result = []
for c in s:
bits = bin(ord(c))[2:]
bits = '00000000'[len(bits):] + bits
#result.extend([int(b) for b in bits])
return bits
def page3_write_button_statusReg1_callback(self, widget, textBox):
try:
entry = int(textBox.get_text(),base=16)
if entry > 0xffffffff:
myMsg = "a ValueError exception occurred\nReg 1 Value > 0xFFFFFFFF."
self.on_erro(widget, myMsg)
else:
# IPbus Transaction
self.hw.getNode("B").getNode("A0").write(entry)
self.hw.dispatch()
print "Wrote",hex(entry),"to STATUS REG 1"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nStatus Reg 1 not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_write_button_ctrlReg1_callback(self, widget, textBox):
try:
entry = int(textBox.get_text(),base=16)
if entry > 0xffffffff:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value > 0xFFFFFFFF."
self.on_erro(widget, myMsg)
else:
# IPbus Transaction
self.hw.getNode("B").getNode("A3").write(entry)
self.hw.dispatch()
print "Wrote",hex(entry),"to 32-bit Scratch Pad Reg\n"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 1 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_write_button_ctrlReg2_callback(self, widget, textBox):
try:
entry = int(textBox.get_text(),base=16)
if entry > 0xffffffff:
myMsg = "a ValueError exception occurred\nCtrl Reg 2 Value > 0xFFFFFFFF."
self.on_erro(widget, myMsg)
else:
self.hw.getNode("DAQ").getNode("A0").write(entry)
self.hw.dispatch()
print "Wrote",hex(entry),"to FIF038 CTRL REG 82"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nFIFO38 Ctrl Reg 2 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error: ", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_write_button_ctrlReg63_callback(self, widget, textBox):
try:
entry = int(textBox.get_text(),base=16)
if entry > 0xffffffff:
myMsg = "a ValueError exception occurred\nCtrl Reg 63 Value > 0xFFFFFFFF."
self.on_erro(widget, myMsg)
else:
self.hw.getNode("CFG").getNode("A63").write(entry)
self.hw.dispatch()
print "Wrote",hex(entry),"to CTRL REG 63"
except IOError as e:
myMsg = "I/O Error: {1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except ValueError:
myMsg = "a ValueError exception occurred\nCtrl Reg 63 Value not hexadecimal."
self.on_erro(widget, myMsg)
except:
print "Unexpected Error Writing to Ctrl Reg 63:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
#========================== READ BUTTONS ===========================
def page3_read_button_statusReg1_callback(self, widget, textBox):
try:
# IPbus Transaction
entry = self.hw.getNode("B").getNode("A0").read()
self.hw.dispatch()
print "Status Reg 1 value =", entry
# Enter into box.
textBox.set_text(hex(entry))
print "Status Reg 1 contains", hex(entry)
print "Should be 0x67_6F_6C_64 = gold in ascii"
except IOError as e:
myMsg = "I/O Error Reading Status Reg 1:\n{1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except:
print "Unexpected Errohw.getNoder Reading Status Reg 1:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_read_button_ctrlReg1_callback(self, widget, textBox):
try:
# IPbus Transaction
entry = self.hw.getNode("B").getNode("A3").read()
self.hw.dispatch()
# Enter into box.
textBox.set_text(hex(entry))
print "Scratch Pad Reg =", hex(entry)
except IOError as e:
myMsg = "I/O Error Reading Ctrl Reg 1:\n{1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except:
print "Unexpected Error Reading Ctrl Reg 1:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_read_button_ctrlReg2_callback(self, widget, textBox):
try:
# IPbus Transaction
entry = self.hw.getNode("DAQ").getNode("A0").read()
self.hw.dispatch()
# Enter into box.
textBox.set_text(hex(entry))
print "FIFO38 Ctrl Reg 82 contains", hex(entry)
except IOError as e:
myMsg = "I/O Error Reading FIFO38 Ctrl Reg 82:\n{1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except:
print "Unexpected Error Reading FIFO38 Ctrl Reg 2:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
def page3_read_button_crtlReg63_callback(self, widget, textBox):
try:
# IPbus Transaction
entry = self.hw.getNode("CFG").getNode("A63").read()
self.hw.dispatch()
# Enter into box.
textBox.set_text(hex(entry))
print "Ctrl Reg 63 contains", hex(entry)
except IOError as e:
myMsg = "I/O Error Reading Ctrl Reg 63:\n{1}".format(e.errno, e.strerror)
self.on_erro(widget, myMsg)
except:
print "Unexpected Error Reading Ctrl Reg 63:\n", sys.exc_info()[0]
self.on_erro(widget, "Unexpected Error:\nDetails printed to shell.")
####################################################################
########################## ##############################
########################## __INIT__ ##############################
########################## ##############################
####################################################################
def __init__(self):
print "loading GUI..."
print
self.tv = gtk.TextView()
self.tv.set_editable(False)
self.tv.set_wrap_mode(gtk.WRAP_WORD)
self.buffer = self.tv.get_buffer()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_default_size(1500,950) ###set_size_request(1440,900)
self.window.set_resizable(True)
self.window.set_title("VMM2 Setup GUI (v3.1.5)")
self.window.set_border_width(0)
self.notebook = gtk.Notebook()
self.notebook.set_size_request(-1,0)
self.notebook.set_tab_pos(gtk.POS_TOP)
self.tab_label_1 = gtk.Label("VMM2 A Config")
self.tab_label_2 = gtk.Label("VMM2 Output")
self.tab_label_3 = gtk.Label("Register Test")
"""print "Configuration Message Array ="
print self.globalreg
print self.reg
print "read back message array ="
#print self.read_msg"""
####################################################
#################### #######################
#################### BUTTONS #######################
#################### #######################
####################################################
self.button_exit = gtk.Button("EXIT")
self.button_exit.set_size_request(-1,-1)
self.button_exit.connect("clicked",self.destroy)
self.button_enableCLKs = gtk.Button("Set en='1'\nEnable CLKs")
self.button_enableCLKs.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_enableCLKs.set_size_request(-1,-1)
self.button_enableCLKs.connect("clicked",self.reset_CLKs)
self.button_reset_acq = gtk.Button("Acq Reset")
self.button_reset_acq.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_reset_acq.set_size_request(-1,-1)
self.button_reset_acq.connect("clicked",self.reset_acq)
self.button_resetVMM = gtk.Button("Global Reset")
self.button_resetVMM.set_size_request(-1,-1)
self.button_resetVMM.connect("clicked",self.reset_global)
self.label_But_Space1 = gtk.Label(" ")
self.label_But_Space2 = gtk.Label(" ")
self.label_But_Space3 = gtk.Label(" ")
self.label_But_Space4 = gtk.Label(" ")
self.label_But_Space5 = gtk.Label(" ")
self.label_But_Space8 = gtk.Label(" ")
self.button_write = gtk.Button("WRITE Config\nRegisters")
self.button_write.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_write.set_size_request(-1,-1)
self.button_write.connect("clicked",self.write_vmmConfigRegisters)
self.button_read_reg = gtk.Button("READ Config\nRegisters")
self.button_read_reg.set_sensitive(False)
self.button_read_reg.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_read_reg.set_size_request(-1,-1)
self.button_read_reg.connect("clicked",self.read_reg)
self.button_cycle_config = gtk.Button("CYCLE\nConfig")
self.button_cycle_config.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_cycle_config.connect("clicked",self.cycle_config)
self.button_cycle_config.set_size_request(-1,-1)
self.button_read_config_VMM_reg = gtk.Button("READ Config\nVMM2 Reg??")
self.button_read_config_VMM_reg.set_sensitive(False)
self.button_read_config_VMM_reg.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_read_config_VMM_reg.set_size_request(-1,-1)
#self.button_read_config_VMM_reg.connect("clicked",self.read_config_VMM_reg)
self.button_run_daq_RO = gtk.Button("RUN DAQ\n Readout")
self.button_run_daq_RO.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_run_daq_RO.set_size_request(-1,-1)
self.button_run_daq_RO.connect("clicked",self.run_daq_RO)
self.button_print_config = gtk.Button("Print\nConfig")
self.button_print_config.child.set_justify(gtk.JUSTIFY_CENTER)
self.button_print_config.set_size_request(-1,-1)
self.button_print_config.connect("clicked",self.print_config)
### No LONGER NEEDED
"""
self.label_IP = gtk.Label("IP ADDRESS")
self.label_IP.set_markup('IP ADDRESS')
self.combo_IP = gtk.combo_box_new_text()
self.combo_IP.connect("changed",self.get_IPaddr_value)
self.combo_IP.append_text("192.168.0.100")
self.combo_IP.append_text("192.168.0.101")
self.combo_IP.append_text("192.168.0.102")
self.combo_IP.append_text("192.168.0.103")
self.combo_IP.append_text("192.168.0.104")
self.combo_IP.append_text("192.168.0.105")
self.combo_IP.append_text("192.168.0.106")
self.combo_IP.append_text("192.168.0.107")
self.combo_IP.append_text("192.168.0.108")
self.combo_IP.append_text("192.168.0.109")
self.combo_IP.set_active(6)
self.button_reset = gtk.Button("Reset")
self.button_reset.set_sensitive(False)
#self.button_reset.set_size_request(50,30)
self.button_reset.connect("clicked",self.reset_params)
"""
self.button_quick_set = gtk.Button("QUICK SET")
self.button_quick_set.connect("clicked",self.quick_set)
self.button_quick_set.set_sensitive(False)
###############################################
################### ##################
################### channels ##################
################### ##################
###############################################
###########################################################
##################### CHANNEL LABELS ######################
###########################################################
self.label_Chan_num_a = gtk.Label(" \n ")
self.label_Chan_SP_a = gtk.Label(" S \n P ")
self.label_Chan_SP_a.set_markup(' S \n P ')
self.label_Chan_SC_a = gtk.Label("S\nC")
self.label_Chan_SC_a.set_markup(' S \n C ')
self.label_Chan_ST_a = gtk.Label("S\nL")
self.label_Chan_ST_a.set_markup(' S \n L')
self.label_Chan_SL_a = gtk.Label("S\nT")
self.label_Chan_SL_a.set_markup(' S \n T ')
self.label_Chan_SM_a = gtk.Label("S\nM")
self.label_Chan_SM_a.set_markup(' S \n M ')
self.label_Chan_SD_a = gtk.Label("SD")
self.label_Chan_SD_a.set_markup(' SD ')
self.label_Chan_SMX_a = gtk.Label("S\nM\nX")
self.label_Chan_SMX_a.set_markup(' S \n M \n X ')
self.label_Chan_SZ10b_a = gtk.Label("SZ10b")
self.label_Chan_SZ10b_a.set_markup(' SZ10b ')
self.label_Chan_SZ8b_a = gtk.Label("SZ8b")
self.label_Chan_SZ8b_a.set_markup(' SZ8b ')
self.label_Chan_SZ6b_a = gtk.Label("SZ6b")
self.label_Chan_SZ6b_a.set_markup(' SZ6b ')
self.box_chan_labels_a = gtk.HBox()
self.box_chan_labels_a.pack_start(self.label_Chan_num_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SP_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SC_a)
self.box_chan_labels_a.pack_start(self.label_Chan_ST_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SL_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SM_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SD_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SMX_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SZ10b_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SZ8b_a)
self.box_chan_labels_a.pack_start(self.label_Chan_SZ6b_a)
self.label_Chan_num_b = gtk.Label(" \n ")
self.label_Chan_SP_b = gtk.Label(" S \n P ")
self.label_Chan_SP_b.set_markup(' S \n P ')
self.label_Chan_SC_b = gtk.Label(" S \n C ")
self.label_Chan_SC_b.set_markup(' S \n C ')
self.label_Chan_ST_b = gtk.Label(" S \n L ")
self.label_Chan_ST_b.set_markup(' S \n L ')
self.label_Chan_SL_b = gtk.Label(" S \n T ")
self.label_Chan_SL_b.set_markup(' S \n T ')
self.label_Chan_SM_b = gtk.Label("S \nM ")
self.label_Chan_SM_b.set_markup(' S \n M ')
self.label_Chan_SD_b = gtk.Label(" SD ")
self.label_Chan_SD_b.set_markup(' SD ')
self.label_Chan_SMX_b = gtk.Label(" S \n M \n X ")
self.label_Chan_SMX_b.set_markup(' S \n M \n X ')
self.label_Chan_SZ10b_b = gtk.Label(" SZ10b ")
self.label_Chan_SZ10b_b.set_markup(' SZ10b ')
self.label_Chan_SZ8b_b = gtk.Label(" SZ8b ")
self.label_Chan_SZ8b_b.set_markup(' SZ8b ')
self.label_Chan_SZ6b_b = gtk.Label(" SZ6b ")
self.label_Chan_SZ6b_b.set_markup(' SZ6b ')
self.box_chan_labels_b = gtk.HBox()
self.box_chan_labels_b.pack_start(self.label_Chan_num_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SP_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SC_b)
self.box_chan_labels_b.pack_start(self.label_Chan_ST_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SL_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SM_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SD_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SMX_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SZ10b_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SZ8b_b)
self.box_chan_labels_b.pack_start(self.label_Chan_SZ6b_b)
##########################################################
##################### CHANNEL BOXES ######################
##########################################################
chan_list = []
for ch_num in range(0, 66):
#print ch_num,
chan_list.append( channel(ch_num) )
self.gbox = gtk.HBox(homogeneous=False,spacing=0)
if ch_num < 10:
self.glabel = gtk.Label( " " + str(ch_num) )
else:
self.glabel = gtk.Label( str(ch_num) )
#self.glabel.set_property( liststore
self.button_SP = gtk.ToggleButton( label="n" )
self.button_SC = gtk.CheckButton()
self.button_SL = gtk.CheckButton()
self.button_ST = gtk.CheckButton()
self.button_SM = gtk.CheckButton()
self.combo_SD = gtk.combo_box_new_text()
self.button_SMX = gtk.CheckButton()
self.combo_SZ10b = gtk.combo_box_new_text()
self.combo_SZ8b = gtk.combo_box_new_text()
self.combo_SZ6b = gtk.combo_box_new_text()
for i in range(16):
self.combo_SD.append_text(str(i) + " mv")
self.combo_SD.set_active(0)
#self.combo_SD.set_active(0)
for i in range(32):
self.combo_SZ10b.append_text(str(i) + " ns")
self.combo_SZ10b.set_active(0)
for i in range(16):
self.combo_SZ8b.append_text(str(i) + " ns")
self.combo_SZ8b.set_active(0)
for i in range(8):
self.combo_SZ6b.append_text(str(i) + " ns")
self.combo_SZ6b.set_active(0)
self.button_SP.connect("toggled",self.SP_callback,ch_num)
self.button_SC.connect("toggled",self.SC_callback,ch_num)
self.button_SL.connect("toggled",self.SL_callback,ch_num)
self.button_ST.connect("toggled",self.ST_callback,ch_num)
self.button_SM.connect("toggled",self.SM_callback,ch_num)
if ch_num < 65:
self.button_SM.set_active(True)
self.combo_SD.connect("changed",self.get_SD_value,ch_num)
self.button_SMX.connect("toggled",self.SMX_callback,ch_num)
self.combo_SZ10b.connect("changed",self.get_SZ10b_value,ch_num)
self.combo_SZ8b.connect("changed",self.get_SZ8b_value,ch_num)
self.combo_SZ6b.connect("changed",self.get_SZ6b_value,ch_num)
self.gbox.pack_start(self.glabel,expand=False)
self.gbox.pack_start(self.button_SP,expand=False)
self.gbox.pack_start(self.button_SC,expand=False)
self.gbox.pack_start(self.button_SL,expand=False)
self.gbox.pack_start(self.button_ST,expand=False)
self.gbox.pack_start(self.button_SM,expand=False)
self.gbox.pack_start(self.combo_SD,expand=False)
self.gbox.pack_start(self.button_SMX,expand=False)
self.gbox.pack_start(self.combo_SZ10b,expand=False)
self.gbox.pack_start(self.combo_SZ8b,expand=False)
self.gbox.pack_start(self.combo_SZ6b,expand=False)
chan_list[ch_num].add_object(self.gbox)
chan_list[ch_num].add_object(self.glabel)
chan_list[ch_num].add_object(self.button_SP)
chan_list[ch_num].add_object(self.button_SC)
chan_list[ch_num].add_object(self.button_SL)
chan_list[ch_num].add_object(self.button_ST)
chan_list[ch_num].add_object(self.button_SM)
chan_list[ch_num].add_object(self.combo_SD)
chan_list[ch_num].add_object(self.button_SMX)
chan_list[ch_num].add_object(self.combo_SZ10b)
chan_list[ch_num].add_object(self.combo_SZ8b)
chan_list[ch_num].add_object(self.combo_SZ6b)
print
#####################################################
################## ###################
################## QUICK SET ###################
################## ###################
#####################################################
#self.label_Chan_num_qs = gtk.Label(" \n ")
self.label_Chan_SP_qs = gtk.Label("SP")
self.label_Chan_SC_qs = gtk.Label("SC")
self.label_Chan_SL_qs = gtk.Label("SL")
self.label_Chan_ST_qs = gtk.Label("ST")
self.label_Chan_SM_qs = gtk.Label("SM")
self.label_Chan_SD_qs = gtk.Label("SD")
self.label_Chan_SMX_qs = gtk.Label("SMX")
#self.box_chan_labels_qs = gtk.HBox()
#self.box_chan_labels_qs.pack_start(self.label_Chan_num_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_SP_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_SC_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_ST_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_SL_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_SM_qs)
#self.box_chan_labels_qs.pack_start(self.label_Chan_SD_qs)
#self.box_chan_labels_qs.pack_end(self.label_Chan_SMX_qs)
#self.check_button_ST = gtk.CheckButton()
#self.box_chan_buttons_qs = gtk.HBox()
#self.box_chan_buttons_qs.pack_start(self.check_button_SP_qs)
#self.box_chan_buttons_qs.pack_start(self.check_button_SC_qs)
#self.box_chan_buttons_qs.pack_start(self.check_button_SL_qs)
#self.box_chan_buttons_qs.pack_start(self.check_button_ST_qs)
#self.box_chan_buttons_qs.pack_start(self.check_button_SM_qs)
#self.box_chan_buttons_qs.pack_start(self.check_button_SD_qs)
#self.box_chan_buttons_qs.pack_end(self.button_SMX_qs)
#self.label_Chan_64 = gtk.Label("64")
self.check_button_SP_qs.set_sensitive(False)
self.check_button_SC_qs.set_sensitive(False)
self.check_button_SL_qs.set_sensitive(False)
self.check_button_ST_qs.set_sensitive(False)
self.check_button_SM_qs.set_sensitive(False)
self.check_button_SD_qs.set_sensitive(False)
self.button_SMX_qs.set_sensitive(False)
self.toggle_button_SP.set_sensitive(False)
self.check_button_SC.set_sensitive(False)
self.check_button_SL.set_sensitive(False)
self.check_button_ST.set_sensitive(False)
self.check_button_SM.set_sensitive(False)
self.combo_SD.set_sensitive(False)
self.button_SMX.set_sensitive(False)
#self.toggle_button_SP = gtk.ToggleButton(label="n")
#self.toggle_button_SP64.connect("toggled",self.tog_but64_callback)
#self.check_button_SC = gtk.CheckButton()
#self.check_button_SL = gtk.CheckButton()
#self.check_button_ST = gtk.CheckButton()
#self.check_button_ST.connect("toggled",self.empty_callback)
#self.check_button_SM = gtk.CheckButton()
#self.combo_SD = gtk.combo_box_new_text()
#self.combo_SD64.connect("changed",self.get_SD64_value)
#for i in range(16):
# self.combo_SD.append_text(str(i) + " mV")
#self.combo_SD.set_active(0)
#self.button_SMX = gtk.CheckButton()han50.pack_start(self.button_SMX50)
self.qs_table = gtk.Table(rows=3, columns=7, homogeneous=False)
self.qs_table.attach(self.label_Chan_SP_qs, left_attach=0, right_attach=1, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SP_qs, left_attach=0, right_attach=1, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.toggle_button_SP, left_attach=0, right_attach=1, top_attach=2, bottom_attach=3, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_SC_qs, left_attach=1, right_attach=2, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SC_qs, left_attach=1, right_attach=2, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SC, left_attach=1, right_attach=2, top_attach=2, bottom_attach=3, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_SL_qs, left_attach=2, right_attach=3, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SL_qs, left_attach=2, right_attach=3, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SL, left_attach=2, right_attach=3, top_attach=2, bottom_attach=3, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_ST_qs, left_attach=3, right_attach=4, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_ST_qs, left_attach=3, right_attach=4, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_ST, left_attach=3, right_attach=4, top_attach=2, bottom_attach=3, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_SM_qs, left_attach=4, right_attach=5, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SM_qs, left_attach=4, right_attach=5, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SM, left_attach=4, right_attach=5, top_attach=2, bottom_attach=3, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_SD_qs, left_attach=5, right_attach=6, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.check_button_SD_qs, left_attach=5, right_attach=6, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
self.qs_table.attach(self.label_Chan_SMX_qs, left_attach=6, right_attach=7, top_attach=0, bottom_attach=1, xpadding=5, ypadding=0)
self.qs_table.attach(self.button_SMX_qs, left_attach=6, right_attach=7, top_attach=1, bottom_attach=2, xpadding=5, ypadding=0)
####################################################
##################### ###################
##################### vmm Global ###################
##################### variables ###################
##################### ###################
####################################################
self.label_Global = gtk.Label("GLOBAL CONFIGURATION")
self.label_Global.set_markup(' GLOBAL CONFIGURATION')
self.label_Global.set_justify(gtk.JUSTIFY_CENTER)
self.box_Global = gtk.HBox()
self.box_Global.pack_start(self.label_Global, expand=False)
self.check_button_SPG = gtk.CheckButton()
self.label_SPG = gtk.Label("Input Charge Polarity")
self.label_SPG.set_markup('Input Charge Polarity ')
self.label_SPGa = gtk.Label(" spg")
self.check_button_SPG.connect("toggled", self.glob_SPG_callback)
self.box_SPG = gtk.HBox()
self.box_SPG.pack_start(self.label_SPG, expand=False)
self.box_SPG.pack_start(self.check_button_SPG, expand=False)
self.box_SPG.pack_start(self.label_SPGa, expand=False)
self.label_SBMX = gtk.Label("Route Analog Monitor to PDO Output")
self.label_SBMX.set_markup('Route Analog Monitor to PDO Output ')
self.check_button_SBMX = gtk.CheckButton("")
self.check_button_SBMX.connect("toggled", self.glob_SBMX_callback)
self.check_button_SBMX.set_active(0)
self.label_SBMXa = gtk.Label(" sbmx")
self.box_SBMX = gtk.HBox()
self.box_SBMX.pack_start(self.label_SBMX, expand=False)
self.box_SBMX.pack_start(self.check_button_SBMX, expand=False)
self.box_SBMX.pack_start(self.label_SBMXa, expand=False)
self.label_SDP = gtk.Label("Disable-at-Peak")
self.label_SDP.set_markup('Disable-at-Peak ')
self.check_button_SDP = gtk.CheckButton()
self.check_button_SDP.connect("toggled", self.glob_SDPeak_callback)
self.label_SDPa = gtk.Label(" sdp")
self.box_SDP = gtk.HBox()
self.box_SDP.pack_start(self.label_SDP, expand=False)
self.box_SDP.pack_start(self.check_button_SDP, expand=False)
self.box_SDP.pack_start(self.label_SDPa, expand=False)
self.label_SBXX = gtk.Label("Analog Output Buffers:")
self.label_SBXX.set_markup('Analog Output Buffers ')
self.check_button_SBFT = gtk.CheckButton("TDO")
self.check_button_SBFT.connect("toggled", self.glob_SBFT_callback)
self.check_button_SBFT.set_active(1)
self.check_button_SBFP = gtk.CheckButton("PDO")
self.check_button_SBFP.connect("toggled", self.glob_SBFP_callback)
self.check_button_SBFP.set_active(1)
self.check_button_SBFM = gtk.CheckButton("MO")
self.check_button_SBFM.connect("toggled", self.glob_SBFM_callback)
self.check_button_SBFM.set_active(1)
self.box_SBXX = gtk.HBox()
self.box_SBXX.pack_start(self.label_SBXX, expand=False)
self.box_SBXX.pack_start(self.check_button_SBFT, expand=False)
self.box_SBXX.pack_start(self.check_button_SBFP, expand=False)
self.box_SBXX.pack_start(self.check_button_SBFM, expand=False)
self.check_button_SLG = gtk.CheckButton()
self.label_SLG = gtk.Label("Leakage Current Disable")
self.label_SLG.set_markup('Leakage Current Disable ')
self.check_button_SLG.connect("toggled", self.glob_SLG_callback)
self.label_SLGa = gtk.Label(" slg")
self.box_SLG = gtk.HBox()
self.box_SLG.pack_start(self.label_SLG, expand=False)
self.box_SLG.pack_start(self.check_button_SLG, expand=False)
self.box_SLG.pack_start(self.label_SLGa, expand=False)
self.label_SM = gtk.Label(" Monitor")
self.label_SM.set_markup(' Monitor ')
self.combo_SM = gtk.combo_box_new_text()
self.combo_SM.connect("changed", self.glob_SM_value)
self.combo_SM.append_text("CHN 1")
self.combo_SM.append_text("CHN 2 | pulser DAC")
self.combo_SM.append_text("CHN 3 | threshold DAC")
self.combo_SM.append_text("CHN 4 | band-gap ref")
self.combo_SM.append_text("CHN 5 | temp")
for i in range(5, 64):
self.combo_SM.append_text("CHN " + str(i+1))
self.combo_SM.set_active(8)
self.label_SCMX = gtk.Label(" scmx")
self.label_SCMX.set_markup('SCMX ')
self.check_button_SCMX = gtk.CheckButton()
self.check_button_SCMX.connect("toggled", self.glob_SCMX_callback)
self.check_button_SCMX.set_active(1)
self.box_SCMX = gtk.HBox()
self.box_SCMX.pack_start(self.label_SCMX, expand=False)
self.box_SCMX.pack_start(self.check_button_SCMX, expand=False)
self.box_SCMX.pack_start(self.label_SM, expand=False)
self.box_SCMX.pack_start(self.combo_SM, expand=False)
self.label_SFA = gtk.Label("ART Enable")
self.label_SFA.set_markup('ART Enable ')
self.check_button_SFA = gtk.CheckButton()
self.check_button_SFA.connect("toggled",self.glob_SFA_callback)
self.check_button_SFA.set_active(True)
self.label_SFAa = gtk.Label(" sfa")
self.label_mode_SFAM = gtk.Label(" Mode ")
self.label_mode_SFAM.set_markup(' Mode ')
self.combo_SFAM = gtk.combo_box_new_text()
self.combo_SFAM.connect("changed",self.glob_SFAM_value)
self.combo_SFAM.append_text("timing-at-threshold")
self.combo_SFAM.append_text("timing-at-peak")
self.combo_SFAM.set_active(0)
self.label_SFAM = gtk.Label(" sfam")
self.box_SFAM = gtk.HBox()
self.box_SFAM.pack_start(self.label_SFA, expand=False)
self.box_SFAM.pack_start(self.check_button_SFA, expand=False)
self.box_SFAM.pack_start(self.label_SFAa, expand=False)
self.box_SFAM.pack_start(self.label_mode_SFAM, expand=False)
self.box_SFAM.pack_start(self.combo_SFAM, expand=False)
self.box_SFAM.pack_start(self.label_SFAM, expand=False)
self.label_Var_ST = gtk.Label("Peaking Time")
self.label_Var_ST.set_markup('Peaking Time ')
self.combo_ST = gtk.combo_box_new_text()
self.combo_ST.connect("changed",self.glob_ST_value)
self.combo_ST.append_text("200 ns")
self.combo_ST.append_text("100 ns")
self.combo_ST.append_text("50 ns")
self.combo_ST.append_text("25 ns")
self.combo_ST.set_active(0)
self.label_ST = gtk.Label(" st")
self.box_ST = gtk.HBox()
self.box_ST.pack_start(self.label_Var_ST, expand=False)
self.box_ST.pack_start(self.combo_ST, expand=False)
self.box_ST.pack_start(self.label_ST, expand=False)
self.check_button_SFM = gtk.CheckButton()
self.label_SFM = gtk.Label("SFM")
self.label_SFM.set_markup('SFM ')
self.check_button_SFM.connect("toggled", self.glob_SFM_callback)
self.check_button_SFM.set_active(1)
self.label_SFMb = gtk.Label(" Doubles the Leakage Current")
self.label_SFMb.set_markup(' (Doubles the Leakage Current)')
self.box_SFM = gtk.HBox()
self.box_SFM.pack_start(self.label_SFM, expand=False)
self.box_SFM.pack_start(self.check_button_SFM, expand=False)
self.box_SFM.pack_start(self.label_SFMb, expand=False)
self.label_Var_SG = gtk.Label("Gain")
self.label_Var_SG.set_markup('Gain ')
self.combo_SG = gtk.combo_box_new_text()
self.combo_SG.connect("changed",self.glob_SG_value)
self.combo_SG.append_text("0.5 (000)")
self.combo_SG.append_text("1 (001)")
self.combo_SG.append_text("3 (010)")
self.combo_SG.append_text("4.5 (011)")
self.combo_SG.append_text("6 (100)")
self.combo_SG.append_text("9 (101)")
self.combo_SG.append_text("12 (110)")
self.combo_SG.append_text("16 (111)")
self.combo_SG.set_active(5)
self.label_SG = gtk.Label(" (mV/fC) sg")
self.box_SG = gtk.HBox()
self.box_SG.pack_start(self.label_Var_SG, expand=False)
self.box_SG.pack_start(self.combo_SG, expand=False)
self.box_SG.pack_start(self.label_SG, expand=False)
self.check_button_SNG = gtk.CheckButton()
self.label_SNG = gtk.Label("Neighbor Triggering")
self.label_SNG.set_markup('Neighbor Triggering ')
self.check_button_SNG.connect("toggled",self.glob_SNG_callback)
self.label_SNGa = gtk.Label(" sng")
self.box_SNG = gtk.HBox()
self.box_SNG.pack_start(self.label_SNG, expand=False)
self.box_SNG.pack_start(self.check_button_SNG,expand=False)
self.box_SNG.pack_start(self.label_SNGa, expand=False)
self.label_STTT = gtk.Label("Timing Outputs")
self.label_STTT.set_markup('Timing Outputs ')
self.check_button_STTT = gtk.CheckButton()
self.check_button_STTT.connect("toggled",self.glob_STTT_callback)
self.label_STTTa = gtk.Label(" sttt")
self.label_mode_STOT = gtk.Label(" Mode ")
self.label_mode_STOT.set_markup(' Mode ')
self.combo_STOT = gtk.combo_box_new_text()
self.combo_STOT.connect("changed",self.glob_STOT_value)
self.combo_STOT.append_text("threshold-to-peak")
self.combo_STOT.append_text("time-over-threshold")
self.combo_STOT.append_text("pulse-at-peak (10ns)")
self.combo_STOT.append_text("peak-to-threshold")
self.combo_STOT.set_active(0)
self.label_STOT = gtk.Label(" stot")
self.box_STXX = gtk.HBox()
self.box_STXX.pack_start(self.label_STTT, expand=False)
self.box_STXX.pack_start(self.check_button_STTT, expand=False)
self.box_STXX.pack_start(self.label_STTTa, expand=False)
self.box_STXX.pack_start(self.label_mode_STOT, expand=False)
self.box_STXX.pack_start(self.combo_STOT, expand=False)
self.box_STXX.pack_start(self.label_STOT, expand=False)
self.label_SSH = gtk.Label("Sub-Hysteresis\nDiscrimination")
self.label_SSH.set_markup('Sub-Hysteresis \nDiscrimination')
self.check_button_SSH = gtk.CheckButton()
self.check_button_SSH.connect("toggled", self.glob_SSH_callback)
self.label_SSHa = gtk.Label(" ssh")
self.box_SSH = gtk.HBox()
self.box_SSH.pack_start(self.label_SSH, expand=False)
self.box_SSH.pack_start(self.check_button_SSH, expand=False)
self.box_SSH.pack_start(self.label_SSHa, expand=False)
self.label_STPP = gtk.Label("Timing Outputs Control 2")
self.label_STPP.set_markup('Timing Outputs Control 2 ')
self.check_button_STPP = gtk.CheckButton()
self.check_button_STPP.connect("toggled", self.glob_STPP_callback)
self.label_STPPa = gtk.Label(" stpp")
self.box_STPP = gtk.HBox()
self.box_STPP.pack_start(self.label_STPP, expand=False)
self.box_STPP.pack_start(self.check_button_STPP, expand=False)
self.box_STPP.pack_start(self.label_STPPa, expand=False)
self.label_Var_STC = gtk.Label("TAC Slope")
self.label_Var_STC.set_markup('TAC Slope ')
self.combo_STC = gtk.combo_box_new_text()
self.combo_STC.connect("changed", self.glob_STC_value)
self.combo_STC.append_text("125 ns (00)")
self.combo_STC.append_text("250 ns (01)")
self.combo_STC.append_text("500 ns (10)")
self.combo_STC.append_text("1000 ns (11)")
self.combo_STC.set_active(2)
self.label_STC = gtk.Label(" stc")
self.box_STC = gtk.HBox()
self.box_STC.pack_start(self.label_Var_STC, expand=False)
self.box_STC.pack_start(self.combo_STC, expand=False)
self.box_STC.pack_start(self.label_STC, expand=False)
self.label_Var_SDT = gtk.Label("Threshold DAC")
self.label_Var_SDT.set_markup('Threshold DAC ')
self.entry_SDT = gtk.Entry(max=4)
self.entry_SDT.set_text("300")
self.entry_SDT.connect("focus-out-event", self.glob_SDT_entry)
self.entry_SDT.connect("activate", self.glob_SDT_entry, self.entry_SDT)
#self.label_Var_SDTb = gtk.Label("Press Enter to SET")
#self.label_Var_SDTb.set_markup(' PRESS <ENTER> to SET')
# self.combo_SDT = gtk.combo_box_new_text()
# for i in range(1024):
# self.combo_SDT.append_text(str(i))
# self.combo_SDT.set_active(0)
self.label_SDT = gtk.Label()
self.box_SDT = gtk.HBox()
self.box_SDT.pack_start(self.label_Var_SDT, expand=False)
self.box_SDT.pack_start(self.entry_SDT, expand=False)
#self.box_SDT.pack_start(self.combo_SDT)
self.box_SDT.pack_start(self.label_SDT, expand=False)
#self.box_SDT.pack_start(self.label_Var_SDTb, expand=False)
self.label_Var_SDP_ = gtk.Label("Test Pulse DAC")
self.label_Var_SDP_.set_markup('Test Pulse DAC ')
self.entry_SDP_ = gtk.Entry(max=4)
self.entry_SDP_.set_text("300")
self.entry_SDP_.connect("focus-out-event", self.glob_SDP_entry ) #,self.entry_SDP_
self.entry_SDP_.connect("activate", self.glob_SDP_entry, self.entry_SDP_)
#self.label_Var_SDP_b = gtk.Label("Press Enter to SET")
#self.label_Var_SDP_b.set_markup(' PRESS <ENTER> to SET')
self.label_SDP_ = gtk.Label()
self.box_SDP_ = gtk.HBox()
self.box_SDP_.pack_start(self.label_Var_SDP_,expand=False)
self.box_SDP_.pack_start(self.entry_SDP_,expand=False)
self.box_SDP_.pack_start(self.label_SDP_,expand=False)
#self.box_SDP_.pack_start(self.label_Var_SDP_b,expand=False)
self.label_variable1 = gtk.Label(" \n ")
self.label_variable2 = gtk.Label(" \n ")
self.label_variable3 = gtk.Label(" \n ")
self.label_variable4 = gtk.Label(" \n ")
self.label_variable5 = gtk.Label(" ")
self.label_variable6 = gtk.Label("Values for Threshold and Test Pulse :")
self.label_variable6.set_markup('Values for Threshold and Test Pulse :')
self.label_variable7 = gtk.Label(" \n ")
self.label_variable9 = gtk.Label(" \n ")
self.label_variable10 = gtk.Label(" 0 <= x <= 1023")
self.label_variable11 = gtk.Label(" ")
self.label_variable12 = gtk.Label("to Set the Values for SDT and SDP_")
self.label_variable12.set_markup('to Set the Values for SDT and SDP_')
self.box_SDP_SDT = gtk.HBox()
self.box_SDP_SDT.pack_start(self.label_variable6,expand=False)
self.box_SDP_SDT.pack_start(self.label_variable10,expand=False)
self.label_Var_SC10b = gtk.Label("10-bit Conversion Time")
self.label_Var_SC10b.set_markup('10-bit Conversion Time ')
self.combo_SC10b = gtk.combo_box_new_text()
self.combo_SC10b.connect("changed", self.glob_SC10b_value)
self.combo_SC10b.append_text("0 ns (00)")
self.combo_SC10b.append_text("1 ns (10)")
self.combo_SC10b.append_text("2 ns (01)")
self.combo_SC10b.append_text("3 ns (11)")
self.combo_SC10b.set_active(0)
self.label_SC10b = gtk.Label(" sc10b")
self.box_SC10b = gtk.HBox()
self.box_SC10b.pack_start(self.label_Var_SC10b, expand=False)
self.box_SC10b.pack_start(self.combo_SC10b, expand=False)
self.box_SC10b.pack_start(self.label_SC10b, expand=False)
self.label_Var_SC8b = gtk.Label("8-bit Conversion Time")
self.label_Var_SC8b.set_markup('8-bit Conversion Time ')
self.combo_SC8b = gtk.combo_box_new_text()
self.combo_SC8b.connect("changed", self.glob_SC8b_value)
self.combo_SC8b.append_text("0 ns (00)")
self.combo_SC8b.append_text("1 ns (10)")
self.combo_SC8b.append_text("2 ns (01)")
self.combo_SC8b.append_text("3 ns (11)")
self.combo_SC8b.set_active(0)
self.label_SC8b = gtk.Label(" sc8b")
self.box_SC8b = gtk.HBox()
self.box_SC8b.pack_start(self.label_Var_SC8b, expand=False)
self.box_SC8b.pack_start(self.combo_SC8b, expand=False)
self.box_SC8b.pack_start(self.label_SC8b, expand=False)
self.label_Var_SC6b = gtk.Label("6-bit Conversion Time")
self.label_Var_SC6b.set_markup('6-bit Conversion Time ')
self.combo_SC6b = gtk.combo_box_new_text()
self.combo_SC6b.connect("changed", self.glob_SC6b_value)
self.combo_SC6b.append_text("0 ns (000)")
self.combo_SC6b.append_text("1 ns (100)")
self.combo_SC6b.append_text("2 ns (010)")
self.combo_SC6b.append_text("3 ns (110)")
self.combo_SC6b.append_text("4 ns (001)")
self.combo_SC6b.append_text("5 ns (101)")
self.combo_SC6b.append_text("6 ns (011)")
self.combo_SC6b.append_text("7 ns (111)")
self.combo_SC6b.set_active(0)
self.label_Var_SC6ba = gtk.Label(" sc6b")
self.box_SC6b = gtk.HBox()
self.box_SC6b.pack_start(self.label_Var_SC6b, expand=False)
self.box_SC6b.pack_start(self.combo_SC6b, expand=False)
self.box_SC6b.pack_start(self.label_Var_SC6ba, expand=False)
self.label_S6b = gtk.Label("6-bit ADC Enable")
self.label_S6b.set_markup('6-bit ADC Enable ')
self.check_button_S6b = gtk.CheckButton()
self.check_button_S6b.connect("toggled", self.glob_S6b_callback)
self.check_button_S6b.set_active(False)
self.label_S6ba = gtk.Label("Disables 8 & 10 bit ADC")
self.label_S6ba.set_markup(' (Disables 8 & 10 bit ADC)')
self.label_S6bb = gtk.Label(" s6b")
self.box_S6b = gtk.HBox()
self.box_S6b.pack_start(self.label_S6b, expand=False)
self.box_S6b.pack_start(self.check_button_S6b, expand=False)
self.box_S6b.pack_start(self.label_S6ba, expand=False)
self.box_S6b.pack_start(self.label_S6bb, expand=False)
self.label_Var_S8b = gtk.Label("8-bit ADC Mode")
self.label_Var_S8b.set_markup('8-bit ADC Mode ')
self.combo_S8b = gtk.CheckButton()
self.combo_S8b.connect("toggled", self.glob_S8b_callback)
self.combo_S8b.set_active(1)
self.label_Var_S8ba = gtk.Label(" s8b")
self.box_S8b = gtk.HBox()
self.box_S8b.pack_start(self.label_Var_S8b, expand=False)
self.box_S8b.pack_start(self.combo_S8b, expand=False)
self.box_S8b.pack_start(self.label_Var_S8ba, expand=False)
self.label_Var_SPDC = gtk.Label("ADCs Enable")
self.label_Var_SPDC.set_markup('ADCs Enable ')
self.button_SPDC = gtk.CheckButton()
self.button_SPDC.connect("toggled", self.glob_SPDC_callback)
self.button_SPDC.set_active(1)
self.label_Var_SPDCa = gtk.Label(" spdc")
self.box_SPDC = gtk.HBox()
self.box_SPDC.pack_start(self.label_Var_SPDC, expand=False)
self.box_SPDC.pack_start(self.button_SPDC, expand=False)
self.box_SPDC.pack_start(self.label_Var_SPDCa, expand=False)
self.label_SDCKS = gtk.Label("Dual Clock Edge\nSerialized Data Enable\n")
self.label_SDCKS.set_markup('Dual Clock Edge\nSerialized Data Enable\n ')
self.check_button_SDCKS = gtk.CheckButton()
self.check_button_SDCKS.connect("toggled", self.glob_SDCKS_callback)
self.label_SDCKSa = gtk.Label(" sdcks")
self.box_SDCKS = gtk.HBox()
self.box_SDCKS.pack_start(self.label_SDCKS, expand=False)
self.box_SDCKS.pack_start(self.check_button_SDCKS, expand=False)
self.box_SDCKS.pack_start(self.label_SDCKSa, expand=False)
self.label_SDCKA = gtk.Label("Dual Clock Edge\nSerialized ART Enable\n")
self.label_SDCKA.set_markup('Dual Clock Edge\nSerialized ART Enable\n ')
self.check_button_SDCKA = gtk.CheckButton()
self.check_button_SDCKA.connect("toggled", self.glob_SDCKA_callback)
self.label_SDCKAa = gtk.Label(" sdcka")
self.box_SDCKA = gtk.HBox()
self.box_SDCKA.pack_start(self.label_SDCKA, expand=False)
self.box_SDCKA.pack_start(self.check_button_SDCKA, expand=False)
self.box_SDCKA.pack_start(self.label_SDCKAa, expand=False)
self.label_SDCK6b = gtk.Label("Dual Clock Edge\nSerialized 6-bit Enable\n")
self.label_SDCK6b.set_markup('Dual Clock Edge\nSerialized 6-bit Enable\n ')
self.check_button_SDCK6b = gtk.CheckButton()
self.check_button_SDCK6b.connect("toggled", self.glob_SDCK6b_callback)
self.label_SDCK6ba = gtk.Label(" sdck6b")
self.box_SDCK6b = gtk.HBox()
self.box_SDCK6b.pack_start(self.label_SDCK6b, expand=False)
self.box_SDCK6b.pack_start(self.check_button_SDCK6b, expand=False)
self.box_SDCK6b.pack_start(self.label_SDCK6ba, expand=False)
self.label_SDRV = gtk.Label("Tristates Analog Outputs")
self.label_SDRV.set_markup('Tristates Analog Outputs ')
self.check_button_SDRV = gtk.CheckButton()
self.check_button_SDRV.connect("toggled", self.glob_SDRV_callback)
self.check_button_SDRV.set_active(0)
self.label_SDRVa = gtk.Label(" sdrv")
self.box_SDRV = gtk.HBox()
self.box_SDRV.pack_start(self.label_SDRV, expand=False)
self.box_SDRV.pack_start(self.check_button_SDRV, expand=False)
self.box_SDRV.pack_start(self.label_SDRVa, expand=False)
self.box_var_labels = gtk.VBox()
self.box_var_labels.set_border_width(10)
self.box_var_labels.pack_start(self.label_variable1)
self.box_var_labels.pack_start(self.label_variable2)
self.box_var_labels.pack_start(self.label_variable3)
self.frame_qs = gtk.Frame()
self.frame_qs.set_shadow_type(gtk.SHADOW_OUT)
self.frame_qs.set_label("QUICK SET")
self.frame_qs.set_label_align(0.5,0.0)
self.box_quick_set = gtk.VBox(homogeneous=False,spacing=0)
self.box_quick_set.set_border_width(20)
self.qs_label = gtk.Label("QUICK SET")
self.box_quick_set.pack_start(self.qs_table)
self.box_quick_set.pack_end(self.button_quick_set)
self.frame_qs.add(self.box_quick_set)
self.label_But_Space6 = gtk.Label(" ")
self.label_But_Space7 = gtk.Label(" ")
self.box_variables = gtk.VBox()
self.box_variables.set_border_width(5)
self.box_variables.pack_start(self.box_Global, expand=False)
self.box_variables.pack_start(self.label_But_Space6, expand=False)
self.box_variables.pack_start(self.label_But_Space7, expand=False)
self.box_variables.pack_start(self.box_SPG, expand=False)
self.box_variables.pack_start(self.box_SDP, expand=False)
self.box_variables.pack_start(self.box_SBMX, expand=False)
self.box_variables.pack_start(self.box_SBXX, expand=False)
self.box_variables.pack_start(self.box_SLG, expand=False)
self.box_variables.pack_start(self.box_SCMX, expand=False)
self.box_variables.pack_start(self.box_SFAM, expand=False)
self.box_variables.pack_start(self.box_ST, expand=False)
self.box_variables.pack_start(self.box_SFM, expand=False)
self.box_variables.pack_start(self.box_SG, expand=False)
self.box_variables.pack_start(self.box_SNG, expand=False)
self.box_variables.pack_start(self.box_STXX, expand=False)
self.box_variables.pack_start(self.box_SSH, expand=False)
self.box_variables.pack_start(self.box_STC, expand=False)
self.box_variables.pack_start(self.box_SC10b, expand=False)
self.box_variables.pack_start(self.box_S8b, expand=False)
self.box_variables.pack_start(self.box_SC8b, expand=False)
self.box_variables.pack_start(self.box_S6b, expand=False)
self.box_variables.pack_start(self.box_SC6b, expand=False)
self.box_variables.pack_start(self.box_SPDC, expand=False)
self.box_variables.pack_start(self.box_SDCKS, expand=False)
self.box_variables.pack_start(self.box_SDCKA, expand=False)
self.box_variables.pack_start(self.box_SDCK6b, expand=False)
self.box_variables.pack_start(self.box_SDRV, expand=False)
self.box_variables.pack_start(self.box_STPP, expand=False)
self.box_variables.pack_start(self.label_variable5,expand=False)
self.box_variables.pack_start(self.label_variable11,expand=False)
self.box_variables.pack_start(self.box_SDT,expand=False)
self.box_variables.pack_start(self.box_SDP_,expand=False)
self.box_variables.pack_start(self.box_SDP_SDT,expand=False)
self.box_variables.pack_start(self.label_variable12,expand=False)
self.box_variables.pack_start(self.label_variable9)
self.box_variables.pack_end(self.frame_qs,expand=False)
###################### FRAME 1 ######################
self.box_buttons = gtk.VBox()
self.box_buttons.set_border_width(5)
self.box_buttons.set_size_request(-1,-1)
#self.box_buttons.pack_start(self.label_IP)
#self.box_buttons.pack_start(self.combo_IP)
self.box_buttons.pack_start(self.label_But_Space8,expand=True)
self.box_buttons.pack_start(self.button_print_config,expand=False)
self.box_buttons.pack_start(self.label_But_Space3,expand=True)
self.box_buttons.pack_start(self.button_write,expand=False)
self.box_buttons.pack_start(self.button_resetVMM,expand=False)
self.box_buttons.pack_start(self.button_cycle_config,expand=False)
self.box_buttons.pack_start(self.button_enableCLKs,expand=False)
self.box_buttons.pack_start(self.button_reset_acq,expand=False)
self.box_buttons.pack_start(self.button_read_reg,expand=False)
self.box_buttons.pack_start(self.label_But_Space4,expand=True)
# self.box_buttons.pack_start(self.button_read_config_VMM_reg,expand=False)
self.box_buttons.pack_start(self.button_run_daq_RO,expand=False)
self.box_buttons.pack_start(self.label_But_Space5,expand=True)
self.box_buttons.pack_start(self.button_exit,expand=False)
self.box_buttons.pack_start(self.label_But_Space2,expand=True)
self.box_buttons.pack_start(self.label_But_Space1,expand=True)
#################################################
################### #############
################### CHANNELS FRAMES #############
################### #############
#################################################
self.frame_2_a = gtk.Frame()
self.frame_2_a.set_border_width(4)
self.frame_2_a.set_shadow_type(gtk.SHADOW_IN)
self.box_channels_1a = gtk.VBox(homogeneous=False,spacing=0)
self.box_channels_a = gtk.VBox(homogeneous=True,spacing=0)
for ch_num in range(1, 33):
self.box_channels_a.pack_start(chan_list[ch_num].chan_obj_list[0])
self.box_channels_1a.pack_start(self.box_chan_labels_a,expand=False)
self.box_channels_1a.pack_start(self.box_channels_a,expand=False)
self.frame_2_a.add(self.box_channels_1a)
self.frame_2_b = gtk.Frame()
self.frame_2_b.set_border_width(4)
self.frame_2_b.set_shadow_type(gtk.SHADOW_IN)
self.box_channels_1b = gtk.VBox(homogeneous=False,spacing=0)
self.box_channels_b = gtk.VBox(homogeneous=True,spacing=0)
for ch_num in range(33, 65):
self.box_channels_b.pack_start(chan_list[ch_num].chan_obj_list[0])
self.box_channels_1b.pack_start(self.box_chan_labels_b,expand=False)
self.box_channels_1b.pack_start(self.box_channels_b,expand=False)
self.frame_2_b.add(self.box_channels_1b)
#################################################
############### #############
############### END CHANNELS FRAMES #############
############### #############
#################################################
self.box_all_channels = gtk.HBox()
self.box_all_channels.pack_start(self.frame_2_a)
self.box_all_channels.pack_start(self.frame_2_b)
self.page1_box = gtk.HBox(homogeneous=0,spacing=0)
self.page1_box.pack_start(self.box_buttons, expand=False)
self.page1_box.pack_start(self.box_all_channels, expand=False)
self.page1_box.pack_end(self.box_variables, expand=True)
##====================== Page 2 =======================##
self.page2_box = gtk.VBox(homogeneous=False)
#self.page2_box.pack_start(self.page2_table, expand=True)
##====================== Page 3 =======================##
self.page3_box = gtk.VBox(homogeneous=False)
self.page3_table = gtk.Table(rows=4, columns=4, homogeneous=False)
self.page3_table.set_row_spacings(10)
self.page3_table.set_col_spacings(10)
self.page3_topfiller_label_1 = gtk.Label("")
self.page3_topfiller_label_1a = gtk.Label("")
self.page3_topfiller_label_2 = gtk.Label(" Registers\n(press buttons to activate)")
self.page3_topfiller_label_2.set_markup(' Registers\n(press buttons to activate)')
self.page3_bottomfiller_label_3 = gtk.Label("")
self.page3_bottomfiller_label_4 = gtk.Label("")
self.page3_top = gtk.VBox(homogeneous=True,spacing=0)
self.page3_top.pack_start(self.page3_topfiller_label_1,expand=True)
self.page3_top.pack_start(self.page3_topfiller_label_1a,expand=True)
self.page3_top.pack_start(self.page3_topfiller_label_2,expand=True)
self.page3_bottom = gtk.VBox(homogeneous=True,spacing=0)
self.page3_bottom.pack_start(self.page3_bottomfiller_label_3,expand=True)
self.page3_bottom.pack_start(self.page3_bottomfiller_label_4,expand=True)
self.page3_leftfiller_label = gtk.Label("38-Bit FIFO CTRL/STATUS\n (0x4000_0082)\n------------------------------ \
\nWRITE\nBit 3 = FIFO38 reset\nBit 5 = FIFO38 read enable\n\nREAD\nBit 0 = almost empty\nBit 1 = empty \
\nBit 2 = almost full\nBit 3 = full")
self.page3_leftfiller_label.set_markup('38-Bit FIFO CTRL/STATUS\n (0x4000_0082)\n------------------------------ \
\nWRITE\nBit 3 = FIFO38 reset\nBit 5 = FIFO38 read enable\n\nREAD\nBit 0 = almost empty\nBit 1 = empty \
\nBit 2 = almost full\nBit 3 = full')
self.page3_rightfiller_label = gtk.Label("CFG CTRL/STATUS REG A63\n (0x4000_00FF)\n------------------------------ \
\nBIT 0 = VMM CFG load Enable\nBIT 1 = cfg_run \
\nBIT 2 = gbl_rst\nBIT 3 = ac1_rst\nBIT 4 = ENA [0,1]\nBIT 5 = CKTP (1=run) \
\nBIT 6 = token clock (1=enable)\nBIT 8:7 = token clock delay\nBIT 11:9 = CFG clock delay\nBIT 31:12 = 0")
self.page3_rightfiller_label.set_markup('CFG CTRL/STATUS REG A63\n (0x4000_00FF)\n------------------------------ \
\nBIT 0 = VMM CFG load Enable\nBIT 1 = cfg_run \
\nBIT 2 = gbl_rst\nBIT 3 = ac1_rst\nBIT 4 = ENA [0,1]\nBIT 5 = CKTP (1=run) \
\nBIT 6 = token clock (1=enable)\nBIT 8:7 = token clock delay\nBIT 11:9 = CFG clock delay\nBIT 31:12 = 0')
self.page3_label_title_a = gtk.Label("32-bit Hexadecimal")
self.page3_label_title_b = gtk.Label("32-bit Hexadecimal")
### page3 text boxes ###
self.page3_write_entry_statusReg1 = gtk.Entry(max=13)
self.page3_write_entry_statusReg1.set_text("Read Only Reg")
self.page3_write_entry_statusReg1.set_editable(False)
self.page3_write_entry_ctrlReg1 = gtk.Entry(max=10)
self.page3_write_entry_ctrlReg1.set_text("0")
self.page3_write_entry_ctrlReg2 = gtk.Entry(max=10)
self.page3_write_entry_ctrlReg2.set_text("0")
self.page3_write_entry_ctrlReg63 = gtk.Entry(max=10)
self.page3_write_entry_ctrlReg63.set_text("0")
### the following have been set to read only
self.page3_read_entry_statusReg1 = gtk.Entry(max=10)
self.page3_read_entry_statusReg1.set_text("")
self.page3_read_entry_statusReg1.set_editable(False)
self.page3_read_entry_ctrlReg1 = gtk.Entry(max=10)
self.page3_read_entry_ctrlReg1.set_text("")
self.page3_read_entry_ctrlReg1.set_editable(False)
self.page3_read_entry_ctrlReg2 = gtk.Entry(max=10)
self.page3_read_entry_ctrlReg2.set_text("")
self.page3_read_entry_ctrlReg2.set_editable(False)
self.page3_read_entry_ctrlReg63 = gtk.Entry(max=10)
self.page3_read_entry_ctrlReg63.set_text("")
self.page3_read_entry_ctrlReg63.set_editable(False)
### page 3 buttons ###
self.page3_write_button_statusReg1 = gtk.Button("WRITE\nStatus Reg 1")
self.page3_write_button_statusReg1.set_sensitive(False)
self.page3_write_button_ctrlReg1 = gtk.Button("WRITE 32-bit\ntest word")
self.page3_write_button_ctrlReg2 = gtk.Button("WRITE FIFO38\nCtrl Reg 82")
self.page3_write_button_ctrlReg63 = gtk.Button("WRITE CFG\nREG 63")
self.page3_write_button_statusReg1.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_write_button_ctrlReg1.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_write_button_ctrlReg2.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_write_button_ctrlReg63.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_write_button_statusReg1.set_size_request(100,45)
self.page3_write_button_ctrlReg1.set_size_request(100,45)
self.page3_write_button_ctrlReg2.set_size_request(100,45)
self.page3_write_button_ctrlReg63.set_size_request(100,45)
self.page3_write_button_statusReg1.connect("clicked", self.page3_write_button_statusReg1_callback,self.page3_write_entry_statusReg1)
self.page3_write_button_ctrlReg1.connect("clicked", self.page3_write_button_ctrlReg1_callback, self.page3_write_entry_ctrlReg1)
self.page3_write_button_ctrlReg2.connect("clicked", self.page3_write_button_ctrlReg2_callback, self.page3_write_entry_ctrlReg2)
self.page3_write_button_ctrlReg63.connect("clicked", self.page3_write_button_ctrlReg63_callback, self.page3_write_entry_ctrlReg63)
self.page3_read_button_statusReg1 = gtk.Button("READ\nStatus Reg 1")
self.page3_read_button_ctrlReg1 = gtk.Button("READ 32-bit\ntest word")
self.page3_read_button_ctrlReg2 = gtk.Button("READ FIFO38\nCtrl Reg 82")
self.page3_read_button_ctrlReg63 = gtk.Button("READ CFG\nREG 63")
self.page3_read_button_statusReg1.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_read_button_ctrlReg1.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_read_button_ctrlReg2.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_read_button_ctrlReg63.child.set_justify(gtk.JUSTIFY_CENTER)
self.page3_read_button_statusReg1.set_size_request(100,45)
self.page3_read_button_ctrlReg1.set_size_request(100,45)
self.page3_read_button_ctrlReg2.set_size_request(100,45)
self.page3_read_button_ctrlReg63.set_size_request(100,45)
self.page3_read_button_statusReg1.connect("clicked", self.page3_read_button_statusReg1_callback, self.page3_read_entry_statusReg1)
self.page3_read_button_ctrlReg1.connect("clicked", self.page3_read_button_ctrlReg1_callback, self.page3_read_entry_ctrlReg1)
self.page3_read_button_ctrlReg2.connect("clicked", self.page3_read_button_ctrlReg2_callback, self.page3_read_entry_ctrlReg2)
self.page3_read_button_ctrlReg63.connect("clicked", self.page3_read_button_crtlReg63_callback, self.page3_read_entry_ctrlReg63)
### pack page 3boxes ###
self.page3_table.attach(self.page3_label_title_a, left_attach=4, right_attach=5, top_attach=0, bottom_attach=1, xpadding=0, ypadding=0)
self.page3_table.attach(self.page3_label_title_b, left_attach=6, right_attach=7, top_attach=0, bottom_attach=1, xpadding=0, ypadding=0)
self.page3_table.attach(self.page3_leftfiller_label, left_attach=0, right_attach=3, top_attach=0, bottom_attach=4, xpadding=40, ypadding=20)
self.page3_table.attach(self.page3_rightfiller_label, left_attach=7, right_attach=10, top_attach=0, bottom_attach=4, xpadding=40, ypadding=20)
self.page3_table.attach(self.page3_write_button_statusReg1, left_attach=3, right_attach=4, top_attach=1, bottom_attach=2, xpadding=10, ypadding=20)
self.page3_table.attach(self.page3_write_button_ctrlReg1, left_attach=3, right_attach=4, top_attach=2, bottom_attach=3, xpadding=10, ypadding=20)
self.page3_table.attach(self.page3_write_button_ctrlReg2, left_attach=3, right_attach=4, top_attach=3, bottom_attach=4, xpadding=10, ypadding=20)
self.page3_table.attach(self.page3_write_button_ctrlReg63, left_attach=3, right_attach=4, top_attach=4, bottom_attach=5, xpadding=10, ypadding=20)
self.page3_table.attach(self.page3_write_entry_statusReg1, left_attach=4, right_attach=5, top_attach=1, bottom_attach=2, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_write_entry_ctrlReg1, left_attach=4, right_attach=5, top_attach=2, bottom_attach=3, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_write_entry_ctrlReg2, left_attach=4, right_attach=5, top_attach=3, bottom_attach=4, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_write_entry_ctrlReg63, left_attach=4, right_attach=5, top_attach=4, bottom_attach=5, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_read_button_statusReg1, left_attach=5, right_attach=6, top_attach=1, bottom_attach=2, xpadding=20, ypadding=20)
self.page3_table.attach(self.page3_read_button_ctrlReg1, left_attach=5, right_attach=6, top_attach=2, bottom_attach=3, xpadding=20, ypadding=20)
self.page3_table.attach(self.page3_read_button_ctrlReg2, left_attach=5, right_attach=6, top_attach=3, bottom_attach=4, xpadding=20, ypadding=20)
self.page3_table.attach(self.page3_read_button_ctrlReg63, left_attach=5, right_attach=6, top_attach=4, bottom_attach=5, xpadding=20, ypadding=20)
self.page3_table.attach(self.page3_read_entry_statusReg1, left_attach=6, right_attach=7, top_attach=1, bottom_attach=2, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_read_entry_ctrlReg1, left_attach=6, right_attach=7, top_attach=2, bottom_attach=3, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_read_entry_ctrlReg2, left_attach=6, right_attach=7, top_attach=3, bottom_attach=4, xpadding=60, ypadding=20)
self.page3_table.attach(self.page3_read_entry_ctrlReg63, left_attach=6, right_attach=7, top_attach=4, bottom_attach=5, xpadding=60, ypadding=20)
self.page3_box.pack_start(self.page3_top)
self.page3_box.pack_start(self.page3_table, fill=False)
self.page3_box.pack_start(self.page3_bottom)
self.page1_scrolledWindow = gtk.ScrolledWindow()
self.page1_viewport = gtk.Viewport()
self.page1_viewport.add(self.page1_box)
self.page1_scrolledWindow.add(self.page1_viewport)
self.notebook.append_page(self.page1_scrolledWindow, self.tab_label_1)
self.notebook.append_page(self.page2_box, self.tab_label_2)
self.notebook.append_page(self.page3_box, self.tab_label_3)
self.box_GUI = gtk.HBox(homogeneous=0,spacing=0)
#self.box_GUI.pack_start(self.myBigButtonsBox, expand=False)
self.box_GUI.pack_end(self.notebook, expand=True)
self.window.add(self.box_GUI)
self.window.show_all()
self.window.connect("destroy",self.destroy)
############################__INIT__################################
############################__INIT__################################
def main(self):
gtk.main()
############################################################
############################################################
################## CONSOLE OUTPUT #########################
############################################################
############################################################
"""
class ConsoleOutput:
def __init__(self, source):
self.source=source
self.buf = []
def update_buffer(self):
vmm.buffer.insert(vmm.buffer.get_end_iter(), ''.join(self.buf))
self.buf = []
def write(self, data):
self.buf.append(data)
if data.endswith('\n'):
gobject.idle_add(self.upodate_buffer)
def __del__(self):
if self.buf != []:
gobject.idle_add(self.update_buffer)
sys.stout = ConsoleOutput(None)
"""
if __name__ == "__main__":
vmm = Vmm()
vmm.main()