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 validate_ioc_test_func(
self,
device_name,
record_func,
child_conn,
validate_pass: bool):
"""Start the IOC with the specified validate method"""
builder.SetDeviceName(device_name)
kwarg = {}
if record_func in [builder.WaveformIn, builder.WaveformOut]:
kwarg = {"length": WAVEFORM_LENGTH} # Must specify when no value
kwarg["validate"] = (
self.validate_always_pass
if validate_pass
else self.validate_always_fail
)
record_func("VALIDATE-RECORD", **kwarg)
dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.LoadDatabase()
softioc.iocInit(dispatcher)
child_conn.send("R")
# Keep process alive while main thread runs CAGET
if child_conn.poll(TIMEOUT):
val = child_conn.recv()
assert val == "D", "Did not receive expected Done character"
def setUp(self):
print self.__doc__
builder.SetDeviceName(self.__doc__.split(" ")[0])
self.controller = PIController.PIController(host="127.0.0.1", port=50000, debug=True)
self.scan = PIStepScan.PIStepScan(self.controller)
random.seed()
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 _create_feedback_records(self, feedback_csv):
"""Create all the feedback records from the .csv file at the location
passed, see create_csv.py for more information; records for two edge
cases are also created.
Args:
feedback_csv (string): The filepath to the .csv file to load the
records in accordance with.
"""
csv_reader = csv.DictReader(open(feedback_csv))
for line in csv_reader:
prefix, suffix = line["pv"].split(":", 1)
builder.SetDeviceName(prefix)
in_record = builder.aIn(suffix,
initial_value=int(line["value"]),
MDEL="-1")
self._feedback_records[(int(line["index"]),
line["field"])] = in_record
# Special case: BPM ID for the x axis of beam position plot, since we
# cannot currently create Waveform records via CSV.
bpm_ids = [
int(pv[2:4]) + 0.1 * int(pv[14:16])
for pv in self.lattice.get_element_pv_names("BPM", "x", pytac.RB)
]
builder.SetDeviceName("SR-DI-EBPM-01")
bpm_id_record = builder.Waveform("BPMID",
NELM=len(bpm_ids),
initial_value=bpm_ids)
self._feedback_records[(0, "bpm_id")] = bpm_id_record
# Special case: EMIT STATUS for the vertical emittance feedback, since
# we cannot currently create mbbIn records via CSV.
builder.SetDeviceName("SR-DI-EMIT-01")
emit_status_record = builder.mbbIn("STATUS",
initial_value=0,
ZRVL=0,
ZRST="Successful",
PINI="YES")
self._feedback_records[(0, "emittance_status")] = emit_status_record
def on_update_test_func(
self, device_name, record_func, conn, always_update
):
builder.SetDeviceName(device_name)
li = builder.longIn("ON-UPDATE-COUNTER-RECORD", initial_value=0)
def on_update_func(new_val):
"""Increments li record each time main out record receives caput"""
li.set(li.get() + 1)
kwarg = {}
if record_func is builder.WaveformOut:
kwarg = {"length": WAVEFORM_LENGTH} # Must specify when no value
record_func(
"ON-UPDATE-RECORD",
on_update=on_update_func,
always_update=always_update,
**kwarg)
def on_update_done(_):
conn.send("C") # "Complete"
# Put to the action record after we've done all other Puts, so we know
# all the callbacks have finished processing
builder.Action("ON-UPDATE-DONE", on_update=on_update_done)
dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.LoadDatabase()
softioc.iocInit(dispatcher)
conn.send("R") # "Ready"
log("CHILD: Sent R over Connection to Parent")
# Keep process alive while main thread runs CAGET
if conn.poll(TIMEOUT):
val = conn.recv()
assert val == "D", "Did not receive expected Done character"
log("CHILD: Received exit command, child exiting")
def __init__(self):
#prefix for the PVs
builder.SetDeviceName("iocmon")
#open the configuration
csv = pd.read_csv("config.csv")
#all slow controls machines
self.machines = {}
#load machines and iocs from the configuration
for i in csv.iterrows():
host = i[1]["host"].strip()
if host not in self.machines:
sleep(0.3)
self.machines[host] = machine(i[1])
self.machines[host].add_ioc(i[1])
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 blocking_test_func(self, device_name, conn):
builder.SetDeviceName(device_name)
count_rec = builder.longIn("BLOCKING-COUNTER", initial_value=0)
async def blocking_update_func(new_val):
"""A function that will block for some time"""
log("CHILD: blocking_update_func starting")
await asyncio.sleep(0.5)
log("CHILD: Finished sleep!")
completed_count = count_rec.get() + 1
count_rec.set(completed_count)
log(
"CHILD: blocking_update_func finished, completed ",
completed_count
)
builder.longOut(
"BLOCKING-REC",
on_update=blocking_update_func,
always_update=True,
blocking=True
)
dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.LoadDatabase()
softioc.iocInit(dispatcher)
conn.send("R") # "Ready"
log("CHILD: Sent R over Connection to Parent")
# Keep process alive while main thread runs CAGET
if conn.poll(TIMEOUT):
val = conn.recv()
assert val == "D", "Did not receive expected Done character"
log("CHILD: Received exit command, child exiting")
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('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
from multiprocessing.connection import Client
import sys
from softioc import softioc, builder, pvlog
from conftest import ADDRESS, select_and_recv
if __name__ == "__main__":
with Client(ADDRESS) as conn:
import cothread
# Being run as an IOC, so parse args and set prefix
parser = ArgumentParser()
parser.add_argument('prefix', help="The PV prefix for the records")
parsed_args = parser.parse_args()
builder.SetDeviceName(parsed_args.prefix)
import sim_records
# Run the IOC
builder.LoadDatabase()
softioc.iocInit()
conn.send("R") # "Ready"
select_and_recv(conn, "D") # "Done"
# Attempt to ensure all buffers flushed - C code (from `import pvlog`)
# may not be affected by these calls...
sys.stdout.flush()
sys.stderr.flush()
from softioc import builder
from mainframe import mainframe
import time
import threading
from datetime import datetime
builder.SetDeviceName("tpc_grid_leak")
#create mainframe object, set telnet port
mf = mainframe(9038)
#_____________________________________________________________________________
def do_monit():
while True:
time.sleep(3)
#print "before: ", datetime.now()
mf.do_read()
#print "after: ", datetime.now()
#_____________________________________________________________________________
def loop_monit():
#initialize lecroy mainframe from config file
mf.init_config()
#periodically read measured current and voltage
tid = threading.Thread(target=do_monit)
tid.start()
def run_ioc(record_configurations: list, conn, set_enum, get_enum):
"""Creates a record and starts the IOC. `initial_value` will be set on
the record at different times based on the `set_enum` parameter."""
builder.SetDeviceName(DEVICE_NAME)
records: List[RecordWrapper] = []
# Create records from the given list
for configuration in record_configurations:
kwarg = {}
(
record_name,
creation_func,
initial_value,
expected_value,
expected_type,
) = configuration
if set_enum == SetValueEnum.INITIAL_VALUE:
kwarg["initial_value"] = initial_value
elif creation_func in [builder.WaveformIn, builder.WaveformOut]:
kwarg["length"] = WAVEFORM_LENGTH # Must specify when no value
# Related to this issue:
# https://github.com/dls-controls/pythonSoftIOC/issues/37
out_rec = creation_func(record_name, **kwarg)
if set_enum == SetValueEnum.SET_BEFORE_INIT:
out_rec.set(initial_value)
records.append(out_rec)
dispatcher = asyncio_dispatcher.AsyncioDispatcher()
builder.LoadDatabase()
softioc.iocInit(dispatcher)
conn.send("R") # "Ready"
# Record list and record config list should always be in line
for record, configuration in zip(records, record_configurations):
(
record_name,
creation_func,
initial_value,
expected_value,
expected_type,
) = configuration
if set_enum == SetValueEnum.SET_AFTER_INIT:
record.set(initial_value)
for record in records:
if get_enum == GetValueEnum.GET:
conn.send(record.get())
# Some tests do a caput and require another .get()
if set_enum == SetValueEnum.CAPUT:
if conn.poll(TIMEOUT):
val = conn.recv()
if val == "G":
conn.send(record.get())
else:
pytest.fail(f"Received unexpected character {val}")
# Keep process alive while main thread works.
# This is most applicable to CAGET tests.
while (True):
if conn.poll(TIMEOUT):
val = conn.recv()
if val == "D": # "Done"
break
import sys
from pkg_resources import require
import logging
require('dls_feedback_manager==1.2')
require('cothread==2.14')
require('numpy==1.11.1')
require('epicsdbbuilder==1.2')
from softioc import softioc, builder
formatter = '%(asctime)s, %(funcName)s, %(levelname)s, %(message)s'
logging.basicConfig(format=formatter, level=logging.INFO)
## Creates name for feedback PVs created during run.
builder.SetDeviceName('BL24I-EA-FDBK-01')
import XBPM_range_manager, XBPM_feedback_manager, XBPM_pid_params
xbpm1_pid_params_list = [
XBPM_pid_params.XBPMPIDParamsClass(KP=-0.0050,
KI=0.000,
KD=0.000,
feedback="FPITCH:FB1",
position="FB1"), # pitch
XBPM_pid_params.XBPMPIDParamsClass(KP=-0.0100,
KI=0.000,
KD=0.000,
feedback="FPITCH:FB2",
position="FB2")
] # roll
import time
import threading
import numpy as np
import ctypes
from Channel import Channel
from softioc import builder, softioc
builder.SetDeviceName('sTGC')
class STGC():
def __init__(self, ip):
self.ip = ip
self.boards = [3, 7]
self.channels = [0]
self.lib = ctypes.cdll.LoadLibrary(
'/star/u/sysuser/users/lukas/CAENHVWrapper-5.82/lib/x64/libcaenhvwrapper.so.5.82'
)
self.handle = ctypes.c_int(0)
self.result0 = self.lib.CAENHV_InitSystem(0, 0, self.ip, "admin",
"admin",
ctypes.byref(self.handle))
print "sTGC is using {0} boards".format(len(self.boards))
#### Process Variables ####
self.pv = []
self.chanlist = []
for i in range(0, len(self.boards)):
base_PV = "{0}:Temp".format(self.boards[i])
self.pv.append(builder.aIn(base_PV))
for j in range(0, len(self.channels)):
self.chanlist.append(
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())
import time
import pandas as pd
import threading
from datetime import datetime
from Channel import Channel
from softioc import builder, softioc, alarm
builder.SetDeviceName('tpc_grid_leak')
import subprocess
class TPC():
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"
# 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())
import time
import threading
import numpy as np
import ctypes
from Channel import Channel
from softioc import builder, softioc
builder.SetDeviceName('MTD:HV')
class MTD():
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 !!!"
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...*~*~")
import time
import threading
import epics
from softioc import builder
from webmon import run_webmon
#local PVs
builder.SetDeviceName("tpc_caen_monit")
#trip indicator
trip_pv = builder.boolIn("is_trip", ZNAM=0, ONAM=1)
#anode sum current, inner and outer
sum_curr_in_pv = builder.aIn("sum_curr_in")
sum_curr_out_pv = builder.aIn("sum_curr_out")
#status of tripped channel
tripstat = 512
#voltage and current values, status value
npv=192
valV = [0. for i in range(npv)]
valI = [0. for i in range(npv)]
valS = [0 for i in range(npv)]
#sector and channel numbers
numSec = [None]*npv
numCh = [None]*npv
#dictionary from PV board and chan to array index
pdict = {}
#inner/outer channels, 0 = inner, 1 = outer
import sys
import logging
from pkg_resources import require
require('cothread==2.13')
require('epicsdbbuilder==1.0')
require("numpy")
from softioc import softioc, builder
import PIController
import PIStepScan
if __name__ == '__main__':
# Prepare params for IOC
builder.SetDeviceName("BL13J-MO-PI-01:SCAN")
builder.stringIn('WHOAMI', VAL='PI scan controller')
builder.stringIn('HOSTNAME', VAL=os.uname()[1])
logging.basicConfig(level=logging.DEBUG)
# Connect to PI controller
# Terminal server
# pi_controller = PIController("172.23.82.5", 4011)
# Ethernet
#pi_controller = PIController.PIController("172.23.82.249", 50000, debug=False)
pi_controller = PIController.PIController("Fake address 01", 50000,
debug=True)
# Step scan logic and records
pi_step_scan = PIStepScan.PIStepScan(pi_controller)
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)
##############################################
from epdchan import epdchan
import paho.mqtt.client as mqtt
from watchdog import watchdog
from softioc import builder
import time
import pandas as pd
#EPD PVs
builder.SetDeviceName('EPD')
#list of all EPD channels as 3-index list
npp = 12
ntile = 31
elist = []
#east/west loop
for ew in range(0, 2):
elist.append([])
#PP loop
for ipp in range(0, npp + 1):
elist[ew].append([])
#tile loop
for itile in range(ntile + 1):
#PP starts at 1, handled in epdchan constructor
elist[ew][ipp].append(epdchan(ew, ipp, itile))
#watchdog timer for 60 seconds
wdt = watchdog(60, elist)
#file holding alarm limit values
csvlim = "limits.csv"
lframe = pd.read_csv(csvlim)
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('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 _create_mirror_records(self, mirror_csv):
"""Create all the mirror records from the .csv file at the location
passed, see create_csv.py for more information.
Args:
mirror_csv (string): The filepath to the .csv file to load the
records in accordance with.
"""
csv_reader = csv.DictReader(open(mirror_csv))
for line in csv_reader:
# Parse arguments.
input_pvs = line["in"].split(", ")
if (len(input_pvs) > 1) and (line["mirror type"]
in ["basic", "inverse", "refresh"]):
raise IndexError("Transformation, refresher, and basic mirror "
"types take only one input PV.")
elif (len(input_pvs) < 2) and (line["mirror type"]
in ["collate", "summate"]):
raise IndexError("collation and summation mirror types take at"
" least two input PVs.")
monitor = input_pvs # need to update to support camonitor multiple
# Convert input pvs to record objects
input_records = []
for pv in input_pvs:
try:
input_records.append(self.all_record_names[pv])
except KeyError:
input_records.append(caget_mask(pv))
# Create output record.
prefix, suffix = line["out"].split(":", 1)
builder.SetDeviceName(prefix)
if line["mirror type"] == "refresh":
# Refresh records come first as do not require an output record
pass
elif line["output type"] == "caput":
output_record = caput_mask(line["out"])
elif line["output type"] == "aIn":
value = float(line["value"])
output_record = builder.aIn(suffix,
initial_value=value,
MDEL="-1")
elif line["output type"] == "longIn":
value = int(line["value"])
output_record = builder.longIn(suffix,
initial_value=value,
MDEL="-1")
elif line["output type"] == "Waveform":
value = numpy.asarray(line["value"][1:-1].split(", "),
dtype=float)
output_record = builder.Waveform(suffix, initial_value=value)
else:
raise TypeError("{0} isn't a supported mirroring output type;"
"please enter 'caput', 'aIn', 'longIn', or "
"'Waveform'.".format(line["output type"]))
# Update the mirror dictionary.
for pv in monitor:
if pv not in self._mirrored_records:
self._mirrored_records[pv] = []
if line["mirror type"] == "basic":
self._mirrored_records[monitor[0]].append(output_record)
elif line["mirror type"] == "inverse":
# Other transformation types are not yet supported.
transformation = transform(numpy.invert, output_record)
self._mirrored_records[monitor[0]].append(transformation)
elif line["mirror type"] == "summate":
summation_object = summate(input_records, output_record)
for pv in monitor:
self._mirrored_records[pv].append(summation_object)
elif line["mirror type"] == "collate":
collation_object = collate(input_records, output_record)
for pv in monitor:
self._mirrored_records[pv].append(collation_object)
elif line["mirror type"] == "refresh":
refresh_object = refresher(self, line["out"])
self._mirrored_records[pv].append(refresh_object)
else:
raise TypeError("{0} is not a valid mirror type; please enter "
"a currently supported type from: 'basic', "
"'summate', 'collate', 'inverse', and "
"'refresh'.".format(line["mirror type"]))
# 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())
