def main(args=None, **kwargs):
from PyTango.server import run
logging.basicConfig(
level=logging.INFO,
format='%(levelname)s %(asctime)-15s %(name)s: %(message)s')
kwargs['green_mode'] = kwargs.get('green_mode', GreenMode.Gevent)
return run((CT2,), args=args, **kwargs)
def run_server(cls, args=None, **kwargs):
"""Run the class as a device server.
It is based on the PyTango.server.run method.
The difference is that the device class
and server name are automatically given.
Args:
args (iterable): args as given in the PyTango.server.run method
without the server name. If None, the sys.argv
list is used
kwargs: the other keywords argument are as given
in the PyTango.server.run method.
"""
if not args:
args = sys.argv[1:]
args = [cls.__name__] + list(args)
return server.run((cls,), args, **kwargs)
tango_log_level = {
"FATAL": 1,
"ERROR": 2,
"WARN": 3,
"INFO": 4,
"DEBUG": 5
}
level_number = tango_log_level[clevel]
clogsource = details[2]
if clogsource == details[2]:
device = DeviceProxy(clogsource)
deviceLogLevel = device.centralLoggingLevel
if clevel == "FATAL" and level_number <= deviceLogLevel:
self.fatal_stream("%s : %s", clogsource, cmessage)
elif clevel == "ERROR" and level_number <= deviceLogLevel:
self.error_stream("%s : %s", clogsource, cmessage)
elif clevel == "WARN" and level_number <= deviceLogLevel:
self.warn_stream("%s : %s", clogsource, cmessage)
elif clevel == "INFO" and level_number <= deviceLogLevel:
self.info_stream("%s : %s", clogsource, cmessage)
elif clevel == "DEBUG" and level_number <= deviceLogLevel:
self.debug_stream("%s : %s", clogsource, cmessage)
else:
pass
else:
pass
run((CentralLogger, ))
@attribute(dtype=str, unit='mBar', access=AttrWriteType.READ)
def P2(self):
"""writes out errors and info too"""
try:
pressure = self.mvc3.read_pressure(2, decimal_places=self.pressure_decimal_places)
if self.get_state() == DevState.FAULT:
self.set_state(DevState.ON)
return pressure
# yes, general exception catching is not good but cs studio otherwise hides this completely (even worse)
except Exception as e:
self.set_state(DevState.FAULT)
return "ERROR: %s" % e
@attribute(dtype=str, unit='mBar', access=AttrWriteType.READ)
def P3(self):
"""writes out errors and info too"""
try:
pressure = self.mvc3.read_pressure(3, decimal_places=self.pressure_decimal_places)
if self.get_state() == DevState.FAULT:
self.set_state(DevState.ON)
return pressure
# yes, general exception catching is not good but cs studio otherwise hides this completely (even worse)
except Exception as e:
self.set_state(DevState.FAULT)
return "ERROR: %s" % e
if __name__ == "__main__":
run([MVC3GaugeControllerTango])
def main(args=None, **kwargs):
return run((Switch, ), args=args, **kwargs)
import time
from PyTango.server import run
from PyTango.server import Device, DeviceMeta
from PyTango.server import attribute, command
class Clock(Device):
__metaclass__ = DeviceMeta
@attribute
def time(self):
"""The time attribute"""
return time.time()
@command(dtype_in=str, dtype_out=str)
def strftime(self, format):
return time.strftime(format)
if __name__ == "__main__":
run([Clock])
def main(args=None, **kwargs):
# PROTECTED REGION ID(VarianMultiGauge.main) ENABLED START #
return run((VarianMultiGauge,), args=args, **kwargs)
def read_Velocity(self):
return self.monitor.getVelocity()
def write_Velocity(self, value):
self.monitor.setVelocity(value)
def read_Acceleration(self):
return self.monitor.getAcceleration()
def write_Acceleration(self, value):
self.monitor.setAcceleration(value)
@PTS.command()
def setHome(self):
self.monitor.setHome()
@PTS.command()
def goHome(self):
self.monitor.moveTo(0.0)
if __name__ == "__main__":
# Start device server
try:
PTS.run((MicosPollux, ))
except PT.DevFailed as e:
print("Tango exception: {:}".format(e.args[0].desc))
except Exception as e:
print("Python exception: {:}".format(repr(e)))
except str as e:
print("String exception: {:}".format(e))
fget="get_current", fset="set_current",
doc="the power supply current")
noise = attribute(label="Noise", dtype=((float,),),
max_dim_x=1024, max_dim_y=1024,
fget="get_noise")
host = device_property(dtype=str)
port = class_property(dtype=int, default_value=9788)
def read_voltage(self):
self.info_stream("get voltage(%s, %d)" % (self.host, self.port))
return 10.0
def get_current(self):
return 2.3456, time(), AttrQuality.ATTR_WARNING
def set_current(self, current):
print("Current set to %f" % current)
def get_noise(self):
return random_sample((1024, 1024))
@command(dtype_in=float)
def ramp(self, value):
print("Ramping up...")
if __name__ == "__main__":
run((PowerSupply,))
def main(args=None, **kwargs):
# PROTECTED REGION ID(SchemaManager.main) ENABLED START #
return run((SchemaManager,), args=args, **kwargs)
class Clock(Device):
__metaclass__ = DeviceMeta
@attribute(dtype=float)
def time(self):
return time.time()
gmtime = attribute(dtype=(int,), max_dim_x=9)
def read_gmtime(self):
return time.gmtime()
@command(dtype_in=float, dtype_out=str)
def ctime(self, seconds):
"""
Convert a time in seconds since the Epoch to a string in local time.
This is equivalent to asctime(localtime(seconds)). When the time tuple
is not present, current time as returned by localtime() is used.
"""
return time.ctime(seconds)
@command(dtype_in=(int,), dtype_out=float)
def mktime(self, tupl):
return time.mktime(tupl)
if __name__ == "__main__":
run([Clock,])
def run_device():
run([Llrf])
def main():
from PyTango.server import run
run((SpecMotor,), verbose=True)
def main(args=None, **kwargs):
from PyTango.server import run
return run((PIDcontroller,), args=args, **kwargs)
@attribute(dtype=str)
def tape(self):
s, keys = "", self.__tape.keys()
min_used, max_used = min(keys), max(keys)
for i in range(min_used, max_used):
s += self.__tape.get(i, self.__blank_symbol)
return s
@command
def step(self):
char_under_head = self.__tape.get(self.__head, self.blank_symbol)
x = self.__state, char_under_head
if x in self.__transition_function:
y = self.__transition_function[x]
self.__tape[self.__head] = y[1]
if y[2] == "R":
self.__head += 1
elif y[2] == "L":
self.__head -= 1
self.__state = y[0]
print self.__state
def dev_state(self):
if self.__state in self.__final_states:
return DevState.ON
else:
return DevState.RUNNING
run([TuringMachine])
def main(args=None, **kwargs):
from PyTango.server import run
return run((SecondOrderImpulseResponse, ), args=args, **kwargs)
def main(args=None, **kwargs):
from PyTango.server import run
return run((LiberaManager,), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(RefCapabilityA.main) ENABLED START #
return run((RefCapabilityA,), args=args, **kwargs)
def main(args=None, **kwargs):
from PyTango.server import run
kwargs['green_mode'] = kwargs.get('green_mode', PyTango.GreenMode.Gevent)
return run((CT2,), args=args, **kwargs)
def move_step(self, direction):
self.set_state(DevState.MOVING)
if direction >= 0:
self.stage.move_relative(self.move_step_size)
else:
self.stage.move_relative(-1 * self.move_step_size)
cmd_move_step = attribute(access=AttrWriteType.WRITE,
dtype=float,
label="moves stage by pregiven step in input direction",
doc="moves stage by pregiven step in input direction")
def write_cmd_move_step(self, direction):
self.move_step(direction)
@attribute(dtype=float,
access=AttrWriteType.READ_WRITE)
def move_step_size_um(self):
return self.move_step_size * 1000.0
def write_move_step_size_um(self, step_um):
self.move_step_size = step_um / 1000.0
@attribute(dtype=str)
def server_message(self):
return sys.stdout.read_stored_message()
if __name__ == "__main__":
run([PIStageTango])
def main(args=None, **kwargs):
from PyTango.server import run
return run((ZObject,), args=args, **kwargs)
def main():
from PyTango import GreenMode
from PyTango.server import run
run([Gpib,], green_mode=GreenMode.Gevent)
def main(args=None, **kwargs):
# PROTECTED REGION ID(RefAlarmHandler.main) ENABLED START #
return run((RefAlarmHandler, ), args=args, **kwargs)
import time
from PyTango.server import run
from PyTango.server import Device, DeviceMeta
from PyTango.server import attribute, command
class Clock(Device):
__metaclass__ = DeviceMeta
@attribute
def time(self):
return time.time()
@command(dtype_in=str, dtype_out=str)
def strftime(self, format):
return time.strftime(format)
if __name__ == "__main__":
run([Clock])
def main(args=None, **kwargs):
# PROTECTED REGION ID(PowerSupply.main) ENABLED START #
return run((PowerSupply, ), args=args, **kwargs)
def main(args=None, **kwargs):
return run((Rack, ), args=args, **kwargs)
def main(args=None, **kwargs):
from PyTango.server import run
return run((MyDevice, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(V4L2Camera.main) ENABLED START #
return run((V4L2Camera, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(SEAWaterflowmeter.main) ENABLED START #
return run((SEAWaterflowmeter,), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(RaspberryButton.main) ENABLED START #
return run((RaspberryButton, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(FileLogger.main) ENABLED START #
return run((FileLogger,), args=args, **kwargs)
self.lake_shore.log_stop()
cmd_log_stop = attribute(access=AttrWriteType.WRITE)
def write_cmd_log_stop(self, _):
self.log_stop()
@pipe
def log_read(self):
"""read the log
used sensors are a range created from the number_of_readings setting in log_options
"""
sensor_list = list(range(1,
self.log_options['number_of_readings'] + 1))
dict_of_sensor_temp_lists = self.lake_shore.log_read(sensor_list)
return 'temperature log', dict_of_sensor_temp_lists
@attribute(dtype=bool)
def log_status(self):
return self.lake_shore.log_status()
@attribute(dtype=str)
def server_message(self):
return sys.stdout.read_stored_message()
if __name__ == "__main__":
run([LakeShore218Tango])
def main(args=None, **kwargs):
# PROTECTED REGION ID(Keithley2100.main) ENABLED START #
return run((Keithley2100,), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(EventsTest.main) ENABLED START #
return run((EventsTest, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(TangoTest.main) ENABLED START #
from PyTango.server import run
return run((TangoTest, ), args=args, **kwargs)
@attribute(dtype=str)
def tape(self):
s, keys = "", self.__tape.keys()
min_used, max_used = min(keys), max(keys)
for i in range(min_used, max_used):
s += self.__tape.get(i, self.__blank_symbol)
return s
@command
def step(self):
char_under_head = self.__tape.get(self.__head, self.blank_symbol)
x = self.__state, char_under_head
if x in self.__transition_function:
y = self.__transition_function[x]
self.__tape[self.__head] = y[1]
if y[2] == "R":
self.__head += 1
elif y[2] == "L":
self.__head -= 1
self.__state = y[0]
print self.__state
def dev_state(self):
if self.__state in self.__final_states:
return DevState.ON
else:
return DevState.RUNNING
run([TuringMachine])
self.set_state(DevState.ON)
self.debug_stream("TurnOn Sending DEBUG")
self.info_stream("TurnOn Sending INFO")
self.warn_stream("TurnOn Sending WARNING")
self.error_stream("TurnOn Sending ERROR")
self.fatal_stream("TurnOn Sending FATAL")
logger.debug("TurnOn Sending debug")
logger.info("TurnOn Sending info")
logger.warning("TurnOn Sending warn")
logger.error("TurnOn Sending error")
logger.fatal("TurnOn Sending fatal")
@command
def TurnOff(self):
# turn off the sending device
self.set_state(DevState.OFF)
self.debug_stream("TurnOff Sending DEBUG")
self.info_stream("TurnOff Sending INFO")
self.warn_stream("TurnOff Sending WARNING")
self.error_stream("TurnOff Sending ERROR")
self.fatal_stream("TurnOff Sending FATAL")
logger.debug("TurnOff Sending debug")
logger.info("TurnOff Sending info")
logger.warning("TurnOff Sending warn")
logger.error("TurnOff Sending error")
logger.fatal("TurnOff Sending fatal")
run([Sending])
# should set the power supply current
self.__current = current
@DebugIt()
def read_noise(self):
return numpy.random.random_integers(1000, size=(100, 100))
@command
def TurnOn(self):
# turn on the actual power supply here
self.set_state(DevState.ON)
@command
def TurnOff(self):
# turn off the actual power supply here
self.set_state(DevState.OFF)
@command(
dtype_in=float,
doc_in="Ramp target current",
dtype_out=bool,
doc_out="True if ramping went well, False otherwise",
)
def Ramp(self, target_current):
# should do the ramping
return True
if __name__ == "__main__":
run([PowerSupply])
def main(args=None, **kwargs):
# PROTECTED REGION ID(RefAchild.main) ENABLED START #
return run((RefAchild, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(SKASubarray.main) ENABLED START #
return run((SKASubarray,), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(CryoCon32.main) ENABLED START #
return run((CryoCon32, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(PfeifferDCU002.main) ENABLED START #
return run((PfeifferDCU002, ), args=args, **kwargs)
def main(args=None, **kwargs):
# PROTECTED REGION ID(SKAPowerSupplyGroup.main) ENABLED START #
return run((SKAPowerSupplyGroup, ), args=args, **kwargs)
#
# NapDevice - PyTango device server example by Tiago to show how
# to implement a non-blocking command with a thread
#
from PyTango.server import Device, DeviceMeta, run
from PyTango.server import command
from PyTango import DevState
import time
import tangoworker
def nap(nap_time, msg="Finished sleeping"):
time.sleep(nap_time)
print(msg)
class NapDevice(Device):
__metaclass__ = DeviceMeta
@command(dtype_in=float)
def nap(self, nap_time):
self.set_state(DevState.ON)
tangoworker.execute(nap, nap_time, msg="I am finished!")
run([NapDevice])
def init_device(self):
Device.init_device(self)
self.__coordinates = (0, 0)
self.set_state(DevState.STANDBY)
@command
def set_coord(self):
self.__coordinates = tuple(co_ord)
self.push_change_event('coordinates', tuple(self.__coordinates), 2)
def get_coordinates(self):
return self.__coordinates
def set_coordinates(self, co_ordinates):
# should set the power supply coordinates
self.__coordinates = co_ordinates
@command
def TurnOn(self):
# turn on the actual power supply here
self.set_state(DevState.ON)
@command
def TurnOff(self):
# turn off the actual power supply here
self.set_state(DevState.OFF)
if __name__ == "__main__":
run([Publish])
