def pv_server(scope='function'):
prefix = 'Ts:'
pvdb = {
'pv1': {
'value': 0,
'hihi': 10,
'high': 5,
'low': -5,
'lolo': -10
},
'pv2': {},
'wf': {
'type': 'char',
'count': 300,
'value': 'some initial message. but it can become very long.'
}
}
server = SimpleServer()
server.createPV(prefix, pvdb)
driver = ioDriver()
server_thread = ServerThread(server)
server_thread.start()
yield server_thread
# After tests have completed or faileds
server_thread.stop()
def setup_server(self) -> None:
"""Configure and start server.
"""
# ignore interrupt in subprocess
signal.signal(signal.SIGINT, signal.SIG_IGN)
logger.info("Initializing CA server")
# initialize channel access server
self.ca_server = SimpleServer()
# create all process variables using the process variables stored in
# pvdb with the given prefix
pvdb, self._child_to_parent_map = build_pvdb(self._input_variables,
self._output_variables)
self.ca_server.createPV(self._prefix + ":", pvdb)
# set up driver for handing read and write requests to process variables
self.ca_driver = CADriver(server=self)
# start the server thread
self.server_thread = ServerThread(self.ca_server)
self.server_thread.start()
logger.info("CA server started")
def start_server(self):
"""
Allow the current server to begin processing
"""
if self.server is None:
self.make_server()
self.stop_server()
self.server_thread = ServerThread(self.server)
self.server_thread.start()
def start_server(self):
"""
Allow the current server to begin processing
"""
logger.debug('Restarting pcaspy server')
if self.server is None:
self.make_server()
self.stop_server()
self.server_thread = ServerThread(self.server)
logger.debug('Pressing start')
self.server_thread.start()
def startEpics(self):
self.server = SimpleServer()
self.server.createPV(prefix=self.pvs['prefix'], \
pvdb={self.pvs['pos_x'] : {'prec' : 3}, })
self.server.createPV(prefix=self.pvs['prefix'], \
pvdb={self.pvs['pos_y'] : {'prec' : 3}, })
self.drv = myDriver()
self.server_thread = ServerThread(self.server)
self.server_thread.start()
def main(args):
server = SimpleServer()
server.createPV(args.prefix, pvdb)
server_thread = ServerThread(server)
driver = Model()
def signal_handler(sig, frame):
print("Shut down server")
server_thread.stop()
signal.signal(signal.SIGINT, signal_handler)
server_thread.start()
maxi = maxigauge(arguments.serial)
maxi.loadSensors()
_logger.info("I got %d sensors in the controller." % maxi._NumSensors)
prefixs = []
pvsGauge = {}
pvsRelay = {}
for j in range(len(maxi.sensors)):
prefixs.append("PG%d" % j)
pvsGauge.update(ioc.pvsPG(prefixs[-1]))
for j in range(len(maxi.relay)):
prefixs.append("RL%d" % j)
pvsRelay.update(ioc.pvsRELAY(prefixs[-1]))
server = SimpleServer()
server.createPV(prefix=arguments.ioc_prefix, pvdb=pvsGauge)
server.createPV(prefix=arguments.ioc_prefix, pvdb=pvsRelay)
driver = ioc.maxigauge_ioc(maxi, prefixs)
server_thread = ServerThread(server)
server_thread.start()
if __name__ == "__main__":
while not (input("Press 'q' to quit: ") == 'q'):
pass
_logger.info("User requested ioc termination. Exiting.")
server_thread.stop()
sys.exit()
def main():
parser = ArgumentParser()
parser.add_argument("--ioc_prefix",
type=str,
help="Global prefix of the IOC.")
parser.add_argument("--pump_prefix",
type=str,
help="Prefix for pump shutter.")
parser.add_argument("--pump_port", type=int, help="GPIO port of pump.")
parser.add_argument("--probe_prefix",
type=str,
help="Prefix for probe shutter.")
parser.add_argument("--probe_port", type=int, help="GPIO port of probe.")
parser.add_argument("--valve_prefix",
type=str,
help="Prefix for pulse valve.")
parser.add_argument("--valve_port",
type=str,
help="Serial port of pulse valve.")
parser.add_argument("--notebook_prefix",
type=str,
help="Prefix for Notebook.")
parser.add_argument("--log_level",
type=str,
help="Logging level for the iocs")
arguments = parser.parse_args()
logging.basicConfig(stream=sys.stdout, level=arguments.log_level)
_logger = logging.getLogger(arguments.ioc_prefix[:-1])
pvdb = {}
pvdb.update(ioc_notebook.make_pvs(arguments.notebook_prefix))
pvdb.update(ioc_RaspiGPIO.make_pvs(arguments.pump_prefix))
pvdb.update(ioc_RaspiGPIO.make_pvs(arguments.probe_prefix))
pvdb.update(ioc_AttoTech.make_pvs(arguments.valve_prefix))
_logger.info("Starting ioc with prefix '%s'.", arguments.ioc_prefix)
server = SimpleServer()
server.createPV(prefix=arguments.ioc_prefix, pvdb=pvdb)
#Setting devices drivers
PumpShutter_driver = RaspiShutter(arguments.pump_port)
if not (PumpShutter_driver.ready):
_logger.ERROR("Error connecting to Pump shutter")
HHGShutter_driver = RaspiShutter(arguments.probe_port)
if not (HHGShutter_driver.ready):
_logger.ERROR("Error connecting to ProbeShutter")
valve_driver = AttoValve(arguments.valve_port)
if not (valve_driver.ready):
_logger.ERROR("Error connecting to AttoValve")
driver = ioc.ioc_raspi1()
valve_ioc = ioc_AttoTech.EpicsAttoTechDriver(valve_driver, driver,
arguments.valve_prefix)
pumpshutter_ioc = ioc_RaspiGPIO.EpicsRaspiShutterDriver(
PumpShutter_driver, driver, arguments.pump_prefix)
hhgshutter_ioc = ioc_RaspiGPIO.EpicsRaspiShutterDriver(
HHGShutter_driver, driver, arguments.probe_prefix)
notebook_ioc = ioc_notebook.NoteBookIoc(driver, arguments.notebook_prefix)
driver.add_ioc(valve_ioc)
driver.add_ioc(pumpshutter_ioc)
driver.add_ioc(hhgshutter_ioc)
driver.add_ioc(notebook_ioc)
server_thread = ServerThread(server)
server_thread.start()
while not (raw_input("Press 'q' to quit: ") == "q"):
pass
server_thread.stop()
_logger.info("User requested ioc termination. Exiting.")
PumpShutter_driver.close()
HHGShutter_driver.close()
valve_driver.close()
