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)
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])