def __init__(self, boardList):
self.boardList = boardList
#pv created to place VPD demand voltages
self.placevalues = builder.boolOut("VPDplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages)
#pv created to turn VPD voltages to 0
self.turnvoltageoff = builder.boolOut("turnoffVPD",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.turnoff_VPD)
self.activefile = 1
self.dictionary = {}
self.chooseFile = builder.longOut("VPD_setting",
initial_value=self.activefile,
on_update=self.request_change)
self.reload = builder.boolOut("reload_VPD",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.reload_dictionary)
self.fileInUse = builder.stringIn("VPDfilestatus")
self.listofstringIns = []
self.maximum = 10
for i in range(self.maximum):
self.listofstringIns.append(
builder.stringIn("VPDfile" + str(i + 1)))
def build_typed_pvs():
"""Build generic PVs"""
dynamic_pvs = {}
builder.aOut('AO:STATIC', **ANALOGUE_VALUES)
builder.aIn('AI:STATIC', **ANALOGUE_VALUES)
dynamic_pvs.update({
builder.aOut('AO:DYNAMIC', **ANALOGUE_VALUES):
lambda pv: increment(pv, 10)})
builder.longOut('LONGO:STATIC',**LONG_VALUES)
builder.longIn('LONGI:STATIC',**LONG_VALUES)
dynamic_pvs.update({
builder.aOut('LONGO:DYNAMIC', **LONG_VALUES):
lambda pv: increment(pv, 10)})
builder.boolOut('BOOLO:STATIC', **BOOLEAN_VALUES)
builder.boolIn('BOOLI:STATIC', **BOOLEAN_VALUES)
dynamic_pvs.update({
builder.boolOut('BOOLO:DYNAMIC', **BOOLEAN_VALUES):
lambda pv: increment(pv, 1)})
builder.stringOut('STRINGO:STATIC', initial_value=STRINGS[0])
builder.stringIn('STRINGI:STATIC', initial_value=STRINGS[0])
dynamic_pvs.update({
builder.stringOut('STRINGO:DYNAMIC', initial_value=STRINGS[0]):
update_string})
enum_pv = builder.mbbOut('MBBO:STATIC', *STRINGS, initial_value=0)
enum_pv = builder.mbbIn('MBBI:STATIC', *STRINGS, initial_value=0)
dynamic_pvs.update({
builder.mbbOut('MBBO:DYNAMIC', *STRINGS, initial_value=0):
lambda pv: increment(pv, len(STRINGS) - 1)})
return lambda: update_pvs(dynamic_pvs)
def __init__(self, boardList):
self.boardList = boardList
#create pv to place BBC voltages
self.placevalues = builder.boolOut("BBCplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages)
self.diction_ary = {}
self.activefile = 1
self.chooseFile = builder.longOut("BBC_setting",
initial_value=self.activefile,
on_update=self.request_change)
#create pv to reload dictionary if changes were made according to the files where demand voltages
#are retrieved from
self.reload = builder.boolOut("reload_BBC",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.reload_dictionary)
#create pv to retrieve file status of BBC
self.fileInUse = builder.stringIn("BBCfilestatus")
#create pv to set BBC voltages to zero
self.turnoffBBC = builder.boolOut("BBCturnoff",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.turnoff_BBC)
self.listofstringIns = []
self.maximum = 10
for i in range(self.maximum):
self.listofstringIns.append(
builder.stringIn("BBCfile" + str(i + 1)))
def __init__(self, machine, name):
builder.SetDeviceName(name)
self.com = ModbusClient(host=machine, port=4000, auto_open=True) #4000
self.com.mode(constants.MODBUS_RTU)
stat = self.com.open()
self.pv_stat = builder.aIn("stat")
self.pv_stat.PREC = 1
self.pv_stat.LOPR = 0
self.pv_stat.HOPR = 100
self.pv_temp = builder.aIn("temp")
self.pv_temp.PREC = 1
self.pv_temp.LOPR = 0
self.pv_temp.HOPR = 100
self.pv_humi = builder.aIn("humidity")
self.pv_humi.PREC = 1
self.pv_humi.LOPR = 0
self.pv_humi.HOPR = 100
self.pv_humi.HSV = "MINOR"
self.pv_humi.HHSV = "MAJOR"
self.pv_humi.HIGH = 45
self.pv_humi.HIHI = 50
self.pv_flow = builder.aIn("flow")
self.pv_flow.PREC = 0
self.pv_flow.LOPR = 0
self.pv_flow.HOPR = 600
self.pv_flow.LOLO = 250
self.pv_flow.LOW = 300
self.pv_flow.HIGH = 480
self.pv_flow.HIHI = 520
self.pv_flow.LSV = "MINOR"
self.pv_flow.LLSV = "MAJOR"
self.pv_flow.HSV = "MINOR"
self.pv_flow.HHSV = "MAJOR"
self.stat_pv = builder.boolIn("status",
ZNAM="off",
ONAM="on",
DESC=name)
self.stat_pv.ZSV = "MAJOR"
self.pv_on = builder.boolOut("on",
ZNAM="0",
ONAM="1",
HIGH=0.1,
on_update=self.turnOn)
self.pv_off = builder.boolOut("off",
ZNAM="0",
ONAM="1",
HIGH=0.1,
on_update=self.turnOff)
self.busy = False
self.pv_act = builder.boolOut("activity", ZNAM="0", ONAM="1", HIGH=1)
self.pv_was_on = builder.boolOut("was_on",
ZNAM="0",
ONAM="1",
HIGH=1.5)
self.pv_was_off = builder.boolOut("was_off",
ZNAM="0",
ONAM="1",
HIGH=1.5)
self.id_temp = 0
self.id_stat = 1
def test_blocking_global_flag_creates_attributes(self):
"""Test that the global blocking flag creates the expected attributes"""
SetBlocking(True)
bo1 = builder.boolOut("OUTREC1")
self.check_record_blocking_attributes(bo1)
SetBlocking(False)
bo2 = builder.boolOut("OUTREC2")
assert bo2._blocking is False
bo3 = builder.boolOut("OUTREC3", blocking=True)
self.check_record_blocking_attributes(bo3)
def __init__(self, boardList):
self.boardList = boardList
self.placevalues = builder.boolOut("PPHVplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages)
self.turnvoltageoff = builder.boolOut("turnoffPPHV",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.turnoff_PPHV)
self.indicator = builder.boolIn("indicator", ZNAM=0, ONAM=1)
def __init__(self, boardList):
self.boardList = boardList
#create pv to place BBC voltages
self.placevalues = builder.boolOut("BBCplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages)
def __init__(self, port):
#telnet communication to lecroy
self.com = lecroy_com(port)
#number of boards and channels per board
self.nbd = 1
self.nchan = 8
#offset in board numbering
self.bdofs = 12
#list of board objects
self.bdlist = []
for ibd in range(self.nbd):
self.bdlist.append(board(ibd, self.nchan, self.bdofs, self.com))
#configuration file
self.confnam = "config.csv"
self.cframe = pandas.read_csv(self.confnam)
#watchdog timer with 10 sec timeout
self.wdt = watchdog(10, self.bdlist)
self.wdt.start()
#mainframe PVs
self.hvstat_pv = builder.boolIn("hvstat", ZNAM="OFF", ONAM="ON")
self.hvon_pv = builder.boolOut("hvon", ZNAM=0, ONAM=1, HIGH=0.1, initial_value=0, on_update=self.do_on)
self.hvoff_pv = builder.boolOut("hvoff", ZNAM=0, ONAM=1, HIGH=0.1, initial_value=0, on_update=self.do_off)
self.link_pv = builder.boolOut("link", ZNAM=0, ONAM=1, HIGH=0.7, initial_value=0)
def __init__(self, ip):
self.readData = builder.boolOut('readData',
on_update=self.place_voltages,
HIGH=0.1)
self.on = builder.boolOut('on', on_update=self.turnOn, HIGH=0.1)
self.off = builder.boolOut('off', on_update=self.turnOff, HIGH=0.1)
self.avrgVolt = builder.aIn('avrgVolt')
self.avrgTemp = builder.longIn('avrgTemp')
self.avrgVoltInner = builder.aIn('avrgVoltInner')
self.avrgVoltOuter = builder.aIn('avrgVoltOuter')
self.marker = builder.longIn('marker')
self.setVoltInner_pv = builder.aOut("setVoltInner",
on_update=self.setVoltInner)
self.setVoltOuter_pv = builder.aOut("setVoltOuter",
on_update=self.setVoltOuter)
self.write_voltages_pv = builder.boolOut("write_voltages",
on_update=self.write_voltages,
HIGH=0.1)
self.datacsv = "data.csv"
self.reset = builder.boolOut("reset", on_update=self.Reset, HIGH=0.1)
self.adj_current_pv = builder.boolOut("adj_current",
on_update=self.adj_current,
HIGH=0.1)
self.adj_msg = "Last done: "
self.adj_stat_pv = builder.stringIn("adj_stat",
initial_value=self.adj_msg +
"none")
self.chlist = []
self.wboard, self.wch = 0, 0
self.ip = ip
self.dictWiener, self.dictTPC = {}, {}
#snmp 5.8 for user defined precision in current readings, compiled according to
# http://file.wiener-d.com/software/net-snmp/net-snmp-CompileForExtendedPrecision-2015-03-06.txt
self.snmpwalk = "/usr/local/Net-SNMP_5-8/code/apps/snmpwalk"
self.snmpset = "/usr/local/Net-SNMP_5-8/code/apps/snmpset -v 2c -c seCrET " + self.ip + " WIENER-CRATE-MIB::"
file = open("file.txt", "w")
file.write(
"TPC sector \t TPC channel \t WIENER board \t WIENER channel \n")
for self.i in xrange(1, 25): # sector
for self.j in xrange(2): # channel
a = '{0} \t\t {1} \t\t {2} \t\t {3} \n'.format(
self.i, self.j, self.wboard, self.wch)
file.write(a)
self.chlist.append(
Channel(self.i, self.j, self.wboard, self.wch,
self.snmpset))
self.dictWiener[(self.wboard, self.wch)] = self.chlist[-1]
self.dictTPC[(self.i, self.j)] = self.chlist[-1]
self.wch += 1
if (self.wch > 15):
self.wboard += 1
self.wch = 0
file.close()
print "Before start, you have to Load Voltage from file through Load Voltage button "
def __init__(self):
print "Initializing the current calibration"
self.caen_imon_val = []
self.caen_imadj_val = []
for ibd in xrange(0, 16, 2):
for ich in xrange(24):
pvnam = "SY4527:{0:02d}:{1:03d}:".format(ibd, ich)
self.caen_imon_val.append(pvnam + "IMon.VAL")
self.caen_imadj_val.append(pvnam + "ImAdj.VAL")
self.run_calib_pv = boolOut("run_calib",
on_update=self.run_calib,
HIGH=0.1)
self.msg = "Last done: "
self.calib_stat_pv = stringIn("calib_stat",
initial_value=self.msg + "none")
def __init__(self, boardList):
self.boardList = boardList
#PVs are created to carry out the functions defined below
self.placevalues = builder.boolOut("ZDCplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages)
self.turnvoltageoff = builder.boolOut("turnoffZDC",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.turnoff_ZDC)
self.placevalues_ZDCSMD = builder.boolOut(
"ZDCSMDplacevalues",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.place_voltages_ZDCSMD)
self.turnSDMoff = builder.boolOut("turnoffSMD",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.turnoff_ZDCSMD)
def __init__(self, boardList, relay):
self.relay = relay
self.boardList = boardList
self.bdbegin = 0
self.bdend = 15
self.cnbegin = 0
self.cnend = 15
#these pvs were created because the user can pick from a range of boards and channels to
#change their limits
self.ACboardb = builder.longOut("ACBbegin", initial_value=self.bdbegin)
self.ACboarde = builder.longOut("ACBend", initial_value=self.bdend)
self.ACchanb = builder.longOut("ACCbegin", initial_value=self.cnbegin)
self.ACchane = builder.longOut("ACCend", initial_value=self.cnend)
#this pv holds the new value for the limit
self.actrip = builder.aOut("ac_tripval", initial_value=10)
#this pv will be a button that the user can press to confirm their changes
self.setactrip = builder.boolOut("setactrip",
ZNAM=0,
ONAM=1,
HIGH=0.1,
on_update=self.set_limits)
def __init__(self, ip):
self.ip = ip
self.boards = [1, 3, 5, 7]
self.channels = [0, 1, 2, 3, 4, 5]
self.lib = ctypes.cdll.LoadLibrary(
'/home/mtd/CAENHVWrapper-5.82/lib/x64/libcaenhvwrapper.so.5.82')
self.handle = ctypes.c_int(0)
#self.result0 = self.lib.CAENHV_InitSystem(2, 0, self.ip, "admin", "admin", ctypes.byref(self.handle)) # for CAEN SY4527
self.result0 = self.lib.CAENHV_InitSystem(
0, 0, self.ip, "admin", "admin",
ctypes.byref(self.handle)) # for CAEN SY1527
print "MTD is using {0} boards".format(len(self.boards))
#### Read INITIAL values for self.on and self.standby ####
try:
self.values = {}
with open("init_val.txt", "r") as f:
for line in f:
variable, value = line.split(",")
self.values[variable] = value.strip("\n")
except:
print "!!! init_val.txt not found, setting default values !!!"
self.values = {
"MTD:HV:SectorSwitch": 0,
"MTD:HV:Standby": 0
} # Setting default values
finally:
self.init_standby = int(self.values["MTD:HV:Standby"])
self.init_switch = int(self.values["MTD:HV:SectorSwitch"])
#### Process Variables creation ####
self.standby = builder.boolOut("Standby",
on_update=self.Standby,
always_update=True,
ZNAM="FULL",
ONAM="StandBy",
initial_value=self.init_standby)
self.full = builder.boolOut("full", on_update=self.full, HIGH=0.1)
#self.off = builder.boolOut('off', on_update=self.turnOff, HIGH=0.1)
#self.on = builder.boolOut('on', on_update=self.turnOn, HIGH=0.1)
self.on = builder.boolOut('SectorSwitch',
on_update=self.Switch,
always_update=True,
ZNAM="OFF",
ONAM="ON",
initial_value=self.init_switch)
self.boardlist_temp = [] # Board Temperature list
self.boardlist_stat = [] # Board Status list
self.chanlist = []
for i in range(0, len(self.boards)):
if self.boards[i] == 1 or self.boards[i] == 5:
base_PV_temp = "Negative:{0}:Temp".format(self.boards[i])
base_PV_stat = "Negative:{0}:status".format(self.boards[i])
else:
base_PV_temp = "Positive:{0}:Temp".format(self.boards[i])
base_PV_stat = "Positive:{0}:status".format(self.boards[i])
self.boardlist_temp.append(builder.aIn(base_PV_temp))
self.boardlist_stat.append(
builder.mbbIn(base_PV_stat, ("All good", 0),
("Power-failure", 1), ("Firmware error", 2),
("HV calib error", 3), ("Temtp calib error", 4),
("Under temp", 5), ("Over temp", 6)))
for j in range(0, len(self.channels)):
self.chanlist.append(
Channel(self.boards[i], self.channels[j], self.lib,
self.handle))
def __init__(self, bdlist, channel, lib, handle):
self.bdlist = bdlist
self.channel = channel
self.lib = lib
self.handle = handle
# Process Variables
if self.bdlist == 1 or self.bdlist == 5:
base_PV = "Negative:{0}:{1}:".format(self.bdlist, self.channel)
else:
base_PV = "Positive:{0}:{1}:".format(self.bdlist, self.channel)
self.readVol = builder.aIn(
base_PV + "vmon",
LOPR=0,
HOPR=8000,
LOW=6200,
LOLO=6000,
LLSV="MAJOR",
LSV="MINOR",
EGU="V",
)
self.readCur = builder.aIn(base_PV + "imon",
LOPR=0,
HOPR=100,
PREC=2,
HIHI=20,
HIGH=15,
HHSV="MAJOR",
HSV="MINOR",
EGU="muA")
self.readStatus = builder.mbbIn(
base_PV + "status", ("Off", 0), ("On", 1), ("Ramping Up", 2),
("Ramping Down", 3), ("Over-Current", 4, "MAJOR"),
("Over-Voltage", 5, "MAJOR"), ("Under-Voltage", 6, "MAJOR"),
("External Trip", 7, "MAJOR"), ("Max V", 8, "MAJOR"),
("Ext. Disable", 9, "MAJOR"), ("Internal Trip", 10, "MAJOR"),
("Calib. Error", 11, "MINOR"), ("Unplugged", 12, "MINOR"),
("reserved forced to 0", 13, "MAJOR"),
("OverVoltage Protection", 14, "MAJOR"),
("PowerFail", 15, "MAJOR"), ("Temperature Error", 16, "MAJOR"))
#self.setOn = builder.boolOut(base_PV+'setOn', on_update=self.setOn, HIGH=1, always_update=True)
#self.setOff = builder.boolOut(base_PV+'setOff', on_update=self.setOff, HIGH=1, always_update=True)
self.setVol = builder.aOut(
base_PV + 'v0set',
LOPR=0,
HOPR=8000,
EGU="V",
initial_value=self.getFloatParameter("V0Set"),
on_update=self.setV0Set,
always_update=True)
self.setMaxVol = builder.aOut(
base_PV + 'setMaxVol',
LOPR=0,
HOPR=8000,
EGU="V",
initial_value=self.getFloatParameter("SVMax"),
on_update=self.setSVMax,
always_update=True)
self.setRampUp = builder.aOut(
base_PV + 'setRampUp',
LOPR=0,
HOPR=50,
EGU="V/s",
initial_value=self.getFloatParameter("RUp"),
on_update=self.setRUp,
always_update=True)
self.setRampDown = builder.aOut(
base_PV + 'setRampDown',
LOPR=0,
HOPR=50,
EGU="V/s",
initial_value=self.getFloatParameter("RDWn"),
on_update=self.setRDWn,
always_update=True)
self.setTripI = builder.aOut(
base_PV + 'setTripI',
LOPR=0,
HOPR=90,
PREC=2,
EGU="muA",
initial_value=self.getFloatParameter("I0Set"),
on_update=self.setI0Set,
always_update=True)
self.setTripTime = builder.aOut(
base_PV + 'setTripTime',
LOPR=0,
HOPR=90,
PREC=1,
EGU="s",
initial_value=self.getFloatParameter("Trip"),
on_update=self.setTrip,
always_update=True)
self.pwOnOff = builder.boolOut(base_PV + "pwonoff",
on_update=self.slideOnOff,
ZNAM="OFF",
ONAM="ON",
always_update=True)
def __init__(self,boardList):
self.boardList = boardList
#pv created to place VPD demand voltages
self.placevalues = builder.boolOut("VPDplacevalues",ZNAM = 0, ONAM = 1, HIGH = 0.1, on_update=self.place_voltages)
#pv created to turn VPD voltages to 0
self.turnvoltageoff = builder.boolOut("turnoffVPD",ZNAM = 0, ONAM = 1, HIGH = 0.1, on_update=self.turnoff_VPD)
def __init__(self, bdlist, channel, lib, handle):
self.bdlist = bdlist
self.channel = channel
self.lib = lib
self.handle = handle
# Process Variables
base_PV = "{0}:{1}:".format(self.bdlist, self.channel)
self.readVol = builder.aIn(base_PV + "vmon",
LOPR=0,
HOPR=2000,
EGU="V")
self.readCur = builder.aIn(base_PV + "imon",
LOPR=0,
HOPR=3,
PREC=2,
HIHI=2,
HIGH=1.5,
HHSV="MAJOR",
HSV="MINOR",
EGU="muA")
self.readStatus = builder.longIn(base_PV + "status")
self.setOn = builder.boolOut(base_PV + 'setOn',
on_update=self.setOn,
HIGH=1)
self.setOff = builder.boolOut(base_PV + 'setOff',
on_update=self.setOff,
HIGH=1)
self.setVol = builder.aOut(
base_PV + 'setVol',
LOPR=0,
HOPR=2000,
EGU="V",
initial_value=self.getFloatParameter("V0Set"),
on_update=self.setV0Set)
self.setMaxVol = builder.aOut(
base_PV + 'setMaxVol',
LOPR=0,
HOPR=2000,
EGU="V",
initial_value=self.getFloatParameter("SVMax"),
on_update=self.setSVMax)
self.setRampUp = builder.aOut(
base_PV + 'setRampUp',
LOPR=0,
HOPR=50,
EGU="V/s",
initial_value=self.getFloatParameter("RUp"),
on_update=self.setRUp)
self.setRampDown = builder.aOut(
base_PV + 'setRampDown',
LOPR=0,
HOPR=50,
EGU="V/s",
initial_value=self.getFloatParameter("RDWn"),
on_update=self.setRDWn)
self.setTripI = builder.aOut(
base_PV + 'setTripI',
LOPR=0,
HOPR=90,
PREC=2,
EGU="muA",
initial_value=self.getFloatParameter("I0Set"),
on_update=self.setI0Set)
self.setTripTime = builder.aOut(
base_PV + 'setTripTime',
LOPR=0,
HOPR=90,
PREC=1,
EGU="s",
initial_value=self.getFloatParameter("Trip"),
on_update=self.setTrip)
def __init__(self, sect_num, chann_num, wboard, wch, snmpset):
self.sect_num = sect_num
self.chann_num = chann_num
self.wboard = wboard
self.wch = wch
self.cmdtemplate = snmpset
base_PV = '{0:02d}:{1:d}:'.format(self.sect_num, self.chann_num)
# Features of the channels
self.volt = builder.aOut(base_PV + 'setVoltage',
on_update=self.setVoltage)
self.curt = builder.aOut(base_PV + 'setCurrent',
on_update=self.setCurrent)
self.wboardpv = builder.longIn(base_PV + 'wboardpv',
initial_value=self.wboard)
self.wchpv = builder.longIn(base_PV + 'wchpv', initial_value=self.wch)
self.setOn = builder.boolOut(base_PV + 'setOn',
on_update=self.setOn,
HIGH=0.1)
self.setOff = builder.boolOut(base_PV + 'setOff',
on_update=self.setOff,
HIGH=0.1)
self.readVol = builder.aIn(base_PV + 'readVol', PREC=1)
if (self.chann_num == 0):
self.readVol.LOPR = 100
self.readVol.HOPR = 130
self.readVol.HIHI = 125
self.readVol.HIGH = 120
self.readVol.LOW = 110
self.readVol.LOLO = 105
self.readVol.LSV = "MINOR"
self.readVol.LLSV = "MAJOR"
self.readVol.HSV = "MINOR"
self.readVol.HHSV = "MAJOR"
if (self.chann_num == 1):
self.readVol.LOPR = 400
self.readVol.HOPR = 500
self.readVol.HIHI = 470
self.readVol.HIGH = 460
self.readVol.LOW = 440
self.readVol.LOLO = 430
self.readVol.LSV = "MINOR"
self.readVol.LLSV = "MAJOR"
self.readVol.HSV = "MINOR"
self.readVol.HHSV = "MAJOR"
self.readTem = builder.longIn(base_PV + 'readTem')
self.imon_read = 0. # measured current from ISEG
self.imon_adj = 0. # adjustment to the measured current
self.readCurr = builder.aIn(base_PV + 'readCurr', PREC=3)
self.status = builder.longIn(base_PV + 'status')
self.setReset = builder.boolOut(base_PV + 'setReset',
on_update=self.setReset,
HIGH=0.1)
if (self.wboard == 0):
self.a = str(self.wch)
else:
if (self.wboard != 0 and self.wch > 9):
self.a = str(self.wboard) + str(self.wch)
else:
self.a = str(self.wboard) + '0' + str(self.wch)
