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, chanID, BoardID, relay):
self.chanID = chanID
self.BoardID = BoardID
self.relay = relay
#print "Hi, I am channel",self.chanID, "and board",self.BoardID
pvname = '{0:02d}:{1:02d}:'.format(self.BoardID, self.chanID)
self.pv_vmon = builder.aIn(pvname + "vmon")
self.pv_vmon.PREC = 2
self.pv_vmon.LOPR = 0
self.pv_vmon.HOPR = 2100
self.pv_current = builder.aIn(pvname + "current")
self.pv_vset = builder.aOut(pvname + "vset",
on_update=self.write_voltage)
self.pv_vset.PREC = 2
self.pv_vset.HOPR = 3000
self.pv_vset.LOPR = 0
self.calc = builder.records.calc(pvname + 'calc', CALC='ABS(A-B)')
self.calc.INPA = self.pv_vset.name
self.calc.INPB = self.pv_vmon.name + " MS"
self.pv_vmon.FLNK = builder.PP(self.calc)
self.pv_vset.FLNK = builder.PP(self.calc)
self.hihi = 30
self.high = 25
self.calc.HIHI = self.hihi
self.calc.HIGH = self.high
self.calc.HHSV = "MAJOR"
self.calc.HSV = "MINOR"
self.ramprate = builder.aOut(pvname + "ramprate",
on_update=self.set_ramp,
initial_value=100)
#print self.calc.name
self.calc_high = epics.PV(self.calc.name + ".HIGH")
self.calc_hihi = epics.PV(self.calc.name + ".HIHI")
def _create_records(self, pvs):
start = time.time()
for pv in pvs:
builder.SetDeviceName(pv)
builder.aIn('I', initial_value=0.1)
builder.aOut('SETI', initial_value=0.1)
print(" Time per pv: {0}".format((time.time() - start) / len(pvs)))
def test_blocking_creates_attributes(self):
"""Test that setting the blocking flag on record creation creates the
expected attributes"""
ao1 = builder.aOut("OUTREC1", blocking=True)
self.check_record_blocking_attributes(ao1)
ao2 = builder.aOut("OUTREC2", blocking=False)
assert ao2._blocking is False
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 test_hlopr_dvrhl_different_values():
"""Test you can set H/LOPR and DRVH/L to different values"""
ao = builder.aOut("DEF", DRVL=1, LOPR=2, HOPR=3, DRVH=4)
assert ao.DRVL.Value() == 1
assert ao.LOPR.Value() == 2
assert ao.HOPR.Value() == 3
assert ao.DRVH.Value() == 4
def main():
if "-v" in sys.argv:
logging.basicConfig(level=logging.DEBUG, format=LOG_FORMAT)
sys.argv.remove("-v")
else:
logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
# Determine the ring mode
if sys.argv[1:]:
ring_mode = sys.argv[1]
else:
try:
ring_mode = str(os.environ["RINGMODE"])
except KeyError:
try:
value = caget("SR-CS-RING-01:MODE", format=2)
ring_mode = value.enums[int(value)]
except ca_nothing:
ring_mode = "DIAD"
# Create PVs.
server = atip_server.ATIPServer(
ring_mode,
DATADIR / "limits.csv",
DATADIR / "feedback.csv",
DATADIR / "mirrored.csv",
DATADIR / "tunefb.csv",
)
# Add special case out record for SOFB to write to.
builder.SetDeviceName("CS-CS-MSTAT-01")
builder.aOut("FBHEART", initial_value=10)
# Start the IOC.
builder.LoadDatabase()
softioc.iocInit()
server.monitor_mirrored_pvs()
server.setup_tune_feedback()
softioc.interactive_ioc(globals())
def __init__(self, ibd, ichan, bdofs, com):
#telnet to lecroy
self.com = com
#id of board
self.ibd = ibd
#id of this channel
self.ichan = ichan
#offset in board numbering
self.bdofs = bdofs
#PVs for the channel
pvnam = "{0:02d}:{1:02d}:".format(self.ibd + self.bdofs, self.ichan)
self.mc_pv = builder.aIn(pvnam + "mc", PREC=3)
self.mv_pv = builder.aIn(pvnam + "mv",
PREC=1,
LLSV="MAJOR",
HHSV="MAJOR",
LOPR=-200.,
HOPR=0.)
self.dv_pv = builder.aOut(pvnam + "dv", on_update=self.put_dv)
def test_drvhl_hlopr_defaults():
"""Test the DRVH/L and H/LOPR default settings"""
# DRVH/L doesn't exist on In records
ai = builder.aIn("FOO")
# KeyError as fields with no value are simply not present in
# epicsdbbuilder's dictionary of fields
with pytest.raises(KeyError):
assert ai.LOPR.Value() is None
with pytest.raises(KeyError):
assert ai.HOPR.Value() is None
ao = builder.aOut("BAR")
with pytest.raises(KeyError):
assert ao.LOPR.Value() is None
with pytest.raises(KeyError):
assert ao.HOPR.Value() is None
with pytest.raises(KeyError):
assert ao.DRVH.Value() is None
with pytest.raises(KeyError):
assert ao.DRVL.Value() is None
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)
# Import the basic framework components.
from softioc import softioc, builder, asyncio_dispatcher
import asyncio
# Create an asyncio dispatcher, the event loop is now running
dispatcher = asyncio_dispatcher.AsyncioDispatcher()
# Set the record prefix
builder.SetDeviceName("MY-DEVICE-PREFIX")
# Create some records
ai = builder.aIn('AI', initial_value=5)
ao = builder.aOut('AO', initial_value=12.45, always_update=True,
on_update=lambda v: ai.set(v))
# Boilerplate get the IOC started
builder.LoadDatabase()
softioc.iocInit(dispatcher)
# Start processes required to be run after iocInit
async def update():
while True:
ai.set(ai.get() + 1)
await asyncio.sleep(1)
asyncio.run_coroutine_threadsafe(update(), dispatcher.loop)
# Finally leave the IOC running with an interactive shell.
softioc.interactive_ioc(globals())
def create_records(configure_scan_function, start_scan_function, min_x, min_y,
min_z, max_x, max_y, max_z):
"""Create the records for the scan interface"""
# We'll return them in a dict
records = {}
# Start the scan
records["start_scan"] = builder.mbbOut('START',
initial_value=0,
PINI='NO',
NOBT=2,
ZRVL=0,
ZRST='Start',
ONVL=1,
ONST='Starting',
on_update=start_scan_function,
always_update=True)
records["configure_scan"] = builder.mbbOut(
'CONFIGURE',
initial_value=0,
PINI='NO',
NOBT=2,
ZRVL=0,
ZRST='Configure',
ONVL=1,
ONST='Configuring',
on_update=configure_scan_function,
always_update=True)
# Status to say we're sending commands
records["STATE"] = builder.mbbIn("STATE",
initial_value=0,
PINI='YES',
NOBT=2,
ZRVL=STATE_NOT_CONFIGRED,
ZRST='Not configured',
ZRSV="INVALID",
ONVL=STATE_PREPARING,
ONST='Preparing',
ONSV="MINOR",
TWVL=STATE_ERROR,
TWST='Error',
TWSV="MAJOR",
THVL=STATE_READY,
THST='Ready',
THSV="NO_ALARM",
FRVL=STATE_SCAN_RUNNING,
FRST="Scan running",
FRSV="NO_ALARM")
# Number of steps in x
records["NX"] = builder.longOut("NX",
initial_value=30,
PINI='YES',
LOPR=1,
HOPR=1000000)
# Number of steps in y
records["NY"] = builder.longOut("NY",
initial_value=30,
PINI='YES',
DRVL=1,
DRVH=1000000)
# Number of steps in z
records["NZ"] = builder.longOut("NZ",
initial_value=30,
PINI='YES',
DRVL=1,
DRVH=1000000)
# x step size / um
records["DX"] = builder.aOut("DX",
initial_value=0.1,
PINI='YES',
DRVL=0.001,
DRVH=300.0,
EGU="um",
PREC=3)
# y step size / um
records["DY"] = builder.aOut("DY",
initial_value=0.1,
PINI='YES',
DRVL=0.001,
DRVH=300.0,
EGU="um",
PREC=3)
# z step size / um
records["DZ"] = builder.aOut("DZ",
initial_value=0.1,
PINI='YES',
DRVL=0.001,
DRVH=300.0,
EGU="um",
PREC=3)
# x centre position / um
records["X0"] = builder.aOut("X0",
initial_value=150,
PINI='YES',
DRVL=min_x,
DRVH=max_x,
EGU="um",
PREC=3)
# y centre position / um
records["Y0"] = builder.aOut("Y0",
initial_value=150,
PINI='YES',
DRVL=min_y,
DRVH=max_y,
EGU="um",
PREC=3)
# z centre position / um
records["Z0"] = builder.aOut("Z0",
initial_value=150,
PINI='YES',
DRVL=min_z,
DRVH=max_z,
EGU="um",
PREC=3)
# Theta rotation about Y / degrees
records["THETA"] = builder.aOut("THETA",
initial_value=0.0,
PINI='YES',
DRVL=-360,
DRVH=360,
EGU="deg",
PREC=3)
# EXPOSURE time / ms
records["EXPOSURE"] = builder.aOut("EXPOSURE",
initial_value=100,
PINI='YES',
DRVL=0.001,
DRVH=300.0,
EGU="ms",
PREC=1)
# Move time / ms
records["MOVETIME"] = builder.aOut("MOVETIME",
initial_value=40,
PINI='YES',
DRVL=0.001,
DRVH=300.0,
EGU="ms",
PREC=1)
return records
def _create_records(self, limits_csv):
"""Create all the standard records from both lattice and element Pytac
fields. Several assumptions have been made for simplicity and
efficiency, these are:
- That bend elements all share a single PV, and are the only
element family to do so.
- That every field that has an out type record (SP) will also have
an in type record (RB).
- That all lattice fields are never setpoint and so only in records
need to be created for them.
Args:
limits_csv (string): The filepath to the .csv file from which to
load the pv limits.
"""
limits_dict = {}
if limits_csv is not None:
csv_reader = csv.DictReader(open(limits_csv))
for line in csv_reader:
limits_dict[line["pv"]] = (
float(line["upper"]),
float(line["lower"]),
int(line["precision"]),
)
bend_in_record = None
for element in self.lattice:
if element.type_ == "BEND":
# Create bends only once as they all share a single PV.
if bend_in_record is None:
value = element.get_value("b0",
units=pytac.ENG,
data_source=pytac.SIM)
get_pv = element.get_pv_name("b0", pytac.RB)
upper, lower, precision = limits_dict.get(
get_pv, (None, None, None))
builder.SetDeviceName(get_pv.split(":", 1)[0])
in_record = builder.aIn(
get_pv.split(":", 1)[1],
LOPR=lower,
HOPR=upper,
PREC=precision,
MDEL="-1",
initial_value=value,
)
set_pv = element.get_pv_name("b0", pytac.SP)
upper, lower, precision = limits_dict.get(
set_pv, (None, None, None))
builder.SetDeviceName(set_pv.split(":", 1)[0])
out_record = builder.aOut(
set_pv.split(":", 1)[1],
LOPR=lower,
HOPR=upper,
PREC=precision,
initial_value=value,
on_update_name=self._on_update,
always_update=True,
)
self._in_records[in_record] = ([element.index], "b0")
self._out_records[out_record] = in_record
bend_in_record = in_record
else:
self._in_records[bend_in_record][0].append(element.index)
else:
# Create records for all other families.
for field in element.get_fields()[pytac.SIM]:
value = element.get_value(field,
units=pytac.ENG,
data_source=pytac.SIM)
get_pv = element.get_pv_name(field, pytac.RB)
upper, lower, precision = limits_dict.get(
get_pv, (None, None, None))
builder.SetDeviceName(get_pv.split(":", 1)[0])
in_record = builder.aIn(
get_pv.split(":", 1)[1],
LOPR=lower,
HOPR=upper,
PREC=precision,
MDEL="-1",
initial_value=value,
)
self._in_records[in_record] = (element.index, field)
try:
set_pv = element.get_pv_name(field, pytac.SP)
except HandleException:
self._rb_only_records.append(in_record)
else:
upper, lower, precision = limits_dict.get(
set_pv, (None, None, None))
builder.SetDeviceName(set_pv.split(":", 1)[0])
out_record = builder.aOut(
set_pv.split(":", 1)[1],
LOPR=lower,
HOPR=upper,
PREC=precision,
initial_value=value,
on_update_name=self._on_update,
always_update=True,
)
self._out_records[out_record] = in_record
# Now for lattice fields.
lat_fields = self.lattice.get_fields()
for field in set(lat_fields[pytac.LIVE]) & set(lat_fields[pytac.SIM]):
# Ignore basic devices as they do not have PVs.
if not isinstance(self.lattice.get_device(field), BasicDevice):
get_pv = self.lattice.get_pv_name(field, pytac.RB)
value = self.lattice.get_value(field,
units=pytac.ENG,
data_source=pytac.SIM)
builder.SetDeviceName(get_pv.split(":", 1)[0])
in_record = builder.aIn(get_pv.split(":", 1)[1],
PREC=4,
initial_value=value,
MDEL="-1")
self._in_records[in_record] = (0, field)
self._rb_only_records.append(in_record)
print("~*~*Woah, we're halfway there, Wo-oah...*~*~")
# Set the ao value, which will trigger on_update for it
sim_records.t_ao.set(value)
print("async update %s (%s)" % (value, sim_records.t_ai.get()))
# Make sure it goes as epicsExit will not flush this for us
sys.stdout.flush()
# Set the ai alarm, but keep the value
sim_records.t_ai.set_alarm(int(value) % 4, alarm.STATE_ALARM)
# Must give the t_ai record time to process
await asyncio.sleep(1)
conn.send("C") # "Complete"
# Set a different initial value
sim_records.t_ai.set(23.45)
# Create a record to set the alarm
t_ao = builder.aOut('ALARM', on_update=callback)
async def on_update_name_callback(value, name):
print(name, "value", value)
builder.longOut(
"NAME-CALLBACK",
initial_value = 3,
always_update=True,
on_update_name=on_update_name_callback,
blocking=True
)
# Run the IOC
builder.LoadDatabase()
softioc.iocInit(asyncio_dispatcher.AsyncioDispatcher())
import sys
import os
from pkg_resources import require
require('cothread==2.13')
require('numpy==1.11.1')
require('epicsdbbuilder==1.0')
from softioc import softioc, builder
from epicsdbbuilder import records #, MS, CP, ImportRecord
##############################################
builder.SetDeviceName('BL04I-EA-XBPM-01')
x1sigcurr = builder.aOut('SumAll:MeanValue_RBV', initial_value=5)
x1r = builder.mbbOut('DRV:Range', initial_value=0)
x1psy = builder.mbbOut('DRV:PositionScaleY', initial_value=790)
x1psx = builder.mbbOut('DRV:PositionScaleX', initial_value=1200)
##############################################
builder.SetDeviceName('BL04I-EA-XBPM-02')
x2sigcurr = builder.aOut('SumAll:MeanValue_RBV', initial_value=7)
x2r = builder.aOut('DRV:Range', initial_value=0)
x2psy = builder.aOut('DRV:PositionScaleY', initial_value=247)
x2psx = builder.aOut('DRV:PositionScaleX', initial_value=1200)
##############################################
import os
from pkg_resources import require
require('cothread==2.13')
require('numpy==1.11.1')
require('epicsdbbuilder==1.0')
from softioc import softioc, builder
from epicsdbbuilder import records #, MS, CP, ImportRecord
"""#builder.SetDeviceName('IOC-TEST')
builder.SetDeviceName('SFX44126-PY-IOC-01')
"""
builder.SetDeviceName('BL03I-EA-XBPM-01')
x1sigcurr = builder.aOut('SumAll:MeanValue_RBV', initial_value=30e-09)
x1r = builder.mbbOut('DRV:Range', initial_value=0)
x1psy = builder.mbbOut('DRV:PositionScaleY', initial_value=1)
x1psx = builder.mbbOut('DRV:PositionScaleX', initial_value=1)
builder.SetDeviceName('BL03I-EA-XBPM-02')
x2sigcurr = builder.aOut('SumAll:MeanValue_RBV', initial_value=1.02991e-06)
x2r = builder.mbbOut('DRV:Range', initial_value=0)
x2psy = builder.mbbOut('DRV:PositionScaleY', initial_value=1)
x2psx = builder.mbbOut('DRV:PositionScaleX', initial_value=1)
builder.SetDeviceName('BL03I-MO-DCM-01')
A = 1
x1SF = builder.aOut('ENERGY', initial_value=12.658)
def build_interactive_sin():
"""
Set up an interactive sine wave that has controls attached to PVs.
Two output waves our generated, one which samples the sine function
at a fixed update rate, and the other which outputs a single cycle
of a sine wave in a waveform PV.
This returns a function that is intended to be passed to Cothread's
Spawn function to provide the updates of the travelling wave.
"""
class Sin(object):
"""
Holds the state required to simulate a sine wave with external
PV controls.
"""
NUM_POINTS = 200
def __init__(self):
self.amp = 1
self.phase = 0
self.wf_pv = None
self.travel_pv = None
self.x = numpy.linspace(0, 2*numpy.pi, self.NUM_POINTS)
self._update_waveform()
def set_phase(self, phase):
self.phase = phase
self._update_waveform()
def set_amp(self, amp):
self.amp = amp
self._update_waveform()
def register_waveform_pv(self, pv):
self.wf_pv = pv
def register_travelling_pv(self, pv):
self.travel_pv = pv
def get_travelling_update_function(self):
UPDATE_RATE = 10
TICK_DELTA = numpy.pi / UPDATE_RATE
X = 0
def run_sin_wave():
x = X
while True:
cothread.Sleep(1./UPDATE_RATE)
x += TICK_DELTA
value = self.amp * numpy.sin(x + self.phase)
if self.travel_pv:
self.travel_pv._RecordWrapper__device.set(value)
return run_sin_wave
def _update_waveform(self):
self.wf = self.amp * numpy.sin(self.x + self.phase)
if self.wf_pv:
self.wf_pv._RecordWrapper__device.set(self.wf)
sin = Sin()
builder.WaveformOut('SINE:X', sin.x)
builder.aOut(
'SINE:AMP', on_update=lambda x: sin.set_amp(x),
LOPR=0, HOPR=2, PREC=2, initial_value=sin.amp)
builder.aOut(
'SINE:PHASE', on_update=lambda x: sin.set_phase(x),
LOPR=0, HOPR=numpy.pi*2, PREC=2, initial_value=sin.phase)
sin.register_travelling_pv(
builder.aOut('SINE:TRAVEL', PREC=2, initial_value=0))
sin.register_waveform_pv(builder.WaveformOut('SINE:WF', sin.wf))
return sin.get_travelling_update_function()
from softioc import builder, softioc
from softioc.builder import records
builder.SetDeviceName("XX-XX-XX-01")
py_record = builder.aOut("VAL1", initial_value=5, on_update=print)
soft_record = records.ao("VAL2", VAL=10)
calc = records.calc("CALC", CALC="A*B", INPA=builder.CP(py_record), B=1)
soft_record.OUT = builder.PP(calc.B)
builder.LoadDatabase()
softioc.iocInit()
softioc.interactive_ioc(globals())
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)
import os
from pkg_resources import require
require('cothread==2.13')
require('numpy==1.11.1')
require('epicsdbbuilder==1.0')
from softioc import softioc, builder
from epicsdbbuilder import records #, MS, CP, ImportRecord
##############################################
builder.SetDeviceName('BL24I-EA-XBPM-01')
x1sigcurr = builder.aOut('SumAll:MeanValue_RBV', initial_value=5)
x1r = builder.mbbOut('DRV:Range', initial_value=0)
x1psy = builder.mbbOut('DRV:PositionScaleY', initial_value=1)
x1psx = builder.mbbOut('DRV:PositionScaleX', initial_value=1)
##############################################
builder.SetDeviceName('BL24I-OP-DCM-01')
A = 1
x1SF = builder.aOut('ENERGY', initial_value=11.882)
pitch = builder.aOut('FPITCH:FB1', initial_value=0.554)
roll = builder.aOut('FPITCH:FB2', initial_value=0.0261)
##############################################
def __init__(self, boardList):
self.boardList = boardList
self.ramprate = builder.aOut("placeramprate",
on_update=self.set_ramp,
initial_value=100)
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 get_temp_max():
return elist[0][0][0].limits.temp_max
#_____________________________________________________________________________
def put_limit(key, val):
#put limit value to file
lframe[key][0] = val
lframe.to_csv(csvlim, index=False)
#PVs to set alarm limits
#_____________________________________________________________________________
def set_imon_max(val):
elist[0][0][0].limits.imon_max = val
put_limit('imon_max', val)
imon_max_pv = builder.aOut("imon_max", on_update=set_imon_max, initial_value=get_imon_max(), PREC=2)
#_____________________________________________________________________________
def set_rmon_min(val):
elist[0][0][0].limits.rmon_min = val
put_limit('rmon_min', val)
rmon_min_pv = builder.aOut("rmon_min", on_update=set_rmon_min, initial_value=get_rmon_min(), PREC=1)
#_____________________________________________________________________________
def set_rmon_max(val):
elist[0][0][0].limits.rmon_max = val
put_limit('rmon_max', val)
rmon_max_pv = builder.aOut("rmon_max", on_update=set_rmon_max, initial_value=get_rmon_max(), PREC=1)
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)
#_____________________________________________________________________________
def put_limit(key, val):
#put limit value to file
lframe[key][0] = val
lframe.to_csv(csvlim, index=False)
#PVs to set alarm limits
#_____________________________________________________________________________
def set_imon_max(val):
elist[0][0][0].limits.imon_max = val
put_limit('imon_max', val)
imon_max_pv = builder.aOut("imon_max",
on_update=set_imon_max,
initial_value=get_imon_max(),
PREC=2)
#_____________________________________________________________________________
def set_rmon_min(val):
elist[0][0][0].limits.rmon_min = val
put_limit('rmon_min', val)
rmon_min_pv = builder.aOut("rmon_min",
on_update=set_rmon_min,
initial_value=get_rmon_min(),
PREC=1)
# Determine the ring mode
if sys.argv[1:]:
ring_mode = sys.argv[1]
else:
try:
ring_mode = str(os.environ['RINGMODE'])
except KeyError:
try:
value = caget('SR-CS-RING-01:MODE', format=2)
ring_mode = value.enums[int(value)]
except ca_nothing:
ring_mode = 'DIAD'
# Create PVs.
server = atip_server.ATIPServer(ring_mode, os.path.join(here, 'limits.csv'),
os.path.join(here, 'feedback.csv'),
os.path.join(here, 'mirrored.csv'),
os.path.join(here, 'tunefb.csv'))
# Add special case out record for SOFB to write to.
builder.SetDeviceName('CS-CS-MSTAT-01')
builder.aOut('FBHEART', initial_value=10)
# Start the IOC.
builder.LoadDatabase()
softioc.iocInit()
server.monitor_mirrored_pvs()
softioc.interactive_ioc(globals())
