Example #1
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(SRIlockin830.init_device) ENABLED START #
     try:
         self.ser = serial.Serial(port=self.SerialPort,
                                  baudrate=self.Speed,
                                  bytesize=serial.EIGHTBITS,
                                  parity=serial.PARITY_NONE,
                                  stopbits=1,
                                  timeout=0.5)
         self.ser.write(bytes("*IDN?\n", "ascii"))
         identification = self.ser.read_until(bytes("\r", "ascii"))
     except:
         self.set_state(PyTango.DevState.FAULT)
         self.set_status("Can't connect to SRI 830")
         self.debug_stream("Can't connect to SRI 830")
         return
     if (identification[0:31] != bytes("Stanford_Research_Systems,SR830",
                                       "ascii")):
         self.set_state(PyTango.DevState.FAULT)
         self.set_status("I do not find an SRI 830 on the serial port")
         self.debug_stream("I do not find an SRI 830 on the serial port")
         return
     self.set_status("Connected to SRI 830")
     self.debug_stream("Connected to SRI 830")
     self.set_state(PyTango.DevState.ON)
Example #2
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(FUGMCP.init_device) ENABLED START #
     try:
         self.ser = serial.Serial(port=self.SerialPort,
                                  baudrate=self.Speed,
                                  bytesize=serial.EIGHTBITS,
                                  parity=serial.PARITY_NONE,
                                  stopbits=1,
                                  timeout=0.5)
         self.ser.write(bytes("*IDN?\n", "ascii"))
         self.identification = self.ser.readline()
     except:
         self.set_state(PyTango.DevState.FAULT)
         self.set_status("Can't connect to FUG MCP")
         self.debug_stream("Can't connect to FUG MCP")
         return
     if (self.identification[0:16] != bytes("FUG HCP 140-1250", "ascii")
             and self.identification[0:15] != bytes("FUG MCP140-1250",
                                                    "ascii")):
         self.set_state(PyTango.DevState.FAULT)
         self.set_status("I do not find a FUG MCP on the serial port")
         self.debug_stream("I do not find a FUG MCP on the serial port")
         return
     self.set_status("Connected to FUG MCP")
     self.debug_stream("Connected to FUG MCP")
     self.ser.write(bytes(">BON?\n", "ascii"))
     resp = self.ser.readline()
     if (resp[:-1] == bytes("BON:1", "ascii")):
         self.set_state(PyTango.DevState.ON)
     else:
         self.set_state(PyTango.DevState.OFF)
    def init_device(self):
        Device.init_device(self)
        # PROTECTED REGION ID(SMSGateway.init_device) ENABLED START #
        self.get_device_properties()

        addr = str(self.IP)
        try:
            socket.inet_aton(addr)
            url = 'http://' + addr
        except socket.error:
            self.set_state(PyTango.DevState.UNKNOWN)
            self.set_status('Invalid IP address')
            logging.error('Invalid IP address', traceback.format_exc())

        try:
            test_connection = requests.get(url)
            time.sleep(3)
            test_connection.raise_for_status()
            self.set_state(PyTango.DevState.ON)
            self.set_status('Connected with SMS Gateway')
            self.url = url
        except socket.error:
            self.set_state(PyTango.DevState.UNKNOWN)
            self.set_status('Bad request made, a 4XX client error or 5XX server error response')
            logging.error('Bad request made, a 4XX client error or 5XX server error response', traceback.format_exc())
Example #4
0
File: CT2.py Project: ESRF-BCU/ct2
    def init_device(self):
        Device.init_device(self)
        for attr in ("state", "status", "last_error", "last_point_nb",
                     "acq_mode", "acq_expo_time", "acq_nb_points",
                     "acq_channels"):
            self.set_change_event(attr, True, False)

        self.__last_error = ""
        self.__last_point_nb = -1
        self.__last_point_nb_timestamp = 0.

        try:
            config = get_config()
            util = PyTango.Util.instance()
            if util.is_svr_starting():
                self.device = CT2Device(config, self.card_name)
                dispatcher.connect(self.__on_error, signal=ErrorSignal,
                                   sender=self.device)
                dispatcher.connect(self.__on_point_nb, signal=PointNbSignal,
                                   sender=self.device)
                dispatcher.connect(self.__on_stop, signal=StopSignal,
                                   sender=self.device)
            else:
                self.apply_config()
            switch_state(self, DevState.ON, "Ready!")
        except Exception as e:
            msg = "Exception initializing device: {0}".format(e)
            self.error_stream(msg)
            switch_state(self, DevState.FAULT, msg)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(WeatherUnderground.init_device) ENABLED START #
     self.set_state(tango.DevState.ON)
     self.debug_stream("api_key_file: %s" % self.api_key_file)
     try:
         key_file = open(self.api_key_file)
         _wu_api_key = key_file.readline()
         self.wu_api_key = _wu_api_key.strip()
         self.debug_stream("api_key: %s" % self.wu_api_key)
     except:
         self.error_stream("failed to read wu_api_key")
         self.set_state(tango.DevState.FAULT)
     self._Grenoble_t = 0.0
     self._Grenoble_t_last_read = 0
     self._Paris_t = 0.0
     self._Paris_t_last_read = 0
     self._Trieste_t = 0.0
     self._Trieste_t_last_read = 0
     self._Barcelona_t = 0.0
     self._Barcelona_t_last_read = 0
     self._Hamburg_t = 0.0
     self._Hamburg_t_last_read = 0
     self._Lund_t = 0.0
     self._Lund_t_last_read = 0
     self._Cape_Town_t = 0.0
     self._Cape_Town_t_last_read = 0
     self._Munich_t = 0.0
     self._Munich_t_last_read = 0
     self._all_towns_attr = {'Grenoble':self.read_Grenoble_t, 'Paris':self.read_Paris_t, 'Trieste':self.read_Trieste_t, 'Barcelona':self.read_Barcelona_t,
                        'Hamburg': self.read_Hamburg_t, 'Lund':self.read_Lund_t, 'Cape Town':self.read_Cape_Town_t, 'Munich':self.read_Munich_t}
     self.http = urllib3.PoolManager()
    def init_device(self):
        self.debug_stream("In init_device:")
        Device.init_device(self)
        self.db = pt.Database()
        self.set_state(pt.DevState.UNKNOWN)
        self.debug_stream("Init camera controller {0}".format(
            self.camera_name))
        params = dict()
        params["imageoffsetx"] = self.roi[0]
        params["imageoffsety"] = self.roi[1]
        params["imagewidth"] = self.roi[2]
        params["imageheight"] = self.roi[3]
        params["triggermode"] = "Off"
        try:
            if self.dev_controller is not None:
                self.dev_controller.stop_thread()
        except Exception as e:
            self.error_info("Error stopping camera controller: {0}".format(e))
        try:
            self.setup_spectrometer()
            self.dev_controller = SpectrometerCameraDeviceController(
                self.camera_name, params, self.wavelengthvector_data,
                self.max_value)
            # self.dev_controller = CameraDeviceController(self.camera_name, params)
        except Exception as e:
            self.error_stream(
                "Error creating camera controller: {0}".format(e))
            return

        self.debug_stream("init_device finished")
        # self.set_state(pt.DevState.ON)
        self.dev_controller.add_state_callback(self.change_state)
Example #7
0
    def init_device(self):
        Device.init_device(self)
        for attr in ("state", "status", "last_error", "last_point_nb",
                     "acq_mode", "acq_expo_time", "acq_nb_points",
                     "acq_channels"):
            self.set_change_event(attr, True, False)

        self.__last_error = ""
        self.__last_point_nb = -1
        self.__last_point_nb_timestamp = 0.

        try:
            config = get_config()
            util = PyTango.Util.instance()
            if util.is_svr_starting():
                self.device = CT2Device(config, self.card_name)
                dispatcher.connect(self.__on_error,
                                   signal=ErrorSignal,
                                   sender=self.device)
                dispatcher.connect(self.__on_point_nb,
                                   signal=PointNbSignal,
                                   sender=self.device)
                dispatcher.connect(self.__on_stop,
                                   signal=StopSignal,
                                   sender=self.device)
            else:
                self.apply_config()
            switch_state(self, DevState.ON, "Ready!")
        except Exception as e:
            msg = "Exception initializing device: {0}".format(e)
            self.error_stream(msg)
            switch_state(self, DevState.FAULT, msg)
Example #8
0
 def init_device(self):
     Device.init_device(self)
     self.set_state(DevState.STANDBY)
     self.__elementLoggingLevel = 5        
     self.__storageLoggingLevel = 5        
     self.__centralLoggingLevel = 5        
     logger.setLevel(logging.DEBUG)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(SEAWaterflowmeter.init_device) ENABLED START #
     self.channel0data=0.0
     self.channel1data=0.0
     self.channel2data=0.0
     self.channel3data=0.0
     for i in self.channels.split(","):
         count[int(i)]=0.0
     self.listofnames=self.channelnames.split(",")
     #print(self.channel0.get_attribute_list)
     #self.channel0.set_label(listofnames[0])
     #self.channel1.set_label(listofnames[1])
     #self.channel2.set_label(listofnames[2])
     #self.channel3.set_label(listofnames[3])        
     GPIO.setmode(GPIO.BCM)     # set up BCM GPIO numbering  
     for i in count:
         GPIO.setup(i,GPIO.IN)
     for i in count:
         GPIO.add_event_detect(i, GPIO.RISING, callback=my_callback)  
     self.set_state(PyTango.DevState.ON)
     self.set_status("Measurement thread is running")
     self.stop_ctrloop = 0
     ctrlloop = ControlThread(self)
     ctrlloop.start()
    def init_device(self):
        Device.init_device(self)
        # PROTECTED REGION ID(AGPolaritySwitch.init_device) ENABLED START #
        try:
            self.ser = serial.Serial(self.SerialPort,
                                     baudrate=self.Speed,
                                     bytesize=8,
                                     parity="N",
                                     stopbits=1,
                                     timeout=1)
            self.ser.write(bytearray("*STAT?\n", "ascii"))
            resp = self.ser.readline()
            dummy = self.ser.readline()
        except:
            self.set_state(PyTango.DevState.FAULT)
            self.set_status("Can't connect to AGPolaritySwitch")
            self.debug_stream("Can't connect to AGPolaritySwitch")
            return
        self.set_status("Connected to AGPolaritySwitch")
        self.debug_stream("Connected to AGPolaritySwitch")

        if (resp == "positive"):  # Only check first gauge to set device status
            self.set_state(PyTango.DevState.ON)
        else:
            self.set_state(PyTango.DevState.OFF)
Example #11
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(CryoCon32.init_device) ENABLED START #
     try:
         self.ser = serial.Serial(self.SerialPort,
                                  self.SerialSpeed,
                                  bytesize=8,
                                  parity="N",
                                  stopbits=1,
                                  timeout=0.5)
         self.ser.write("*IDN?\n")
         idn = self.ser.readline()
         if (idn[0:16] != "Cryocon Model 32"):
             self.set_status("Not a CryoCon32 on serial port")
             self.debug_stream("Not a CryoCon32 on serial port")
             return
         self.ser.write("INPUT A:UNITS K\n")
         self.ser.write("LOOP 1:TYPE PID\n")
         self.ser.write("CONTROL?\n")
         mode = self.ser.readline()
         if mode[0:3] == "OFF":
             self.set_state(PyTango.DevState.OFF)
         else:
             self.set_state(PyTango.DevState.ON)
     except:
         self.set_state(PyTango.DevState.FAULT)
         self.set_status("Can't connect to CryoCon32")
         self.debug_stream("Can't connect to CryoCon32")
         return
     self.set_status("Connected to CryoCon32")
     self.debug_stream("Connected to CryoCon32")
Example #12
0
 def __init__(self, klass, name):
     self.wavelengthvector_data = np.array([])
     self.max_value = 1.0
     self.controller = None  # type: SpectrometerCameraController
     self.state_dispatcher = None  # type: StateDispatcher
     self.db = None
     Device.__init__(self, klass, name)
    def init_device(self):
        Device.init_device(self)
        # PROTECTED REGION ID(SKABaseDevice.init_device) ENABLED START #

        # Initialize attribute values.
        self._build_state = '{}, {}, {}'.format(release.name, release.version,
                                                release.description)
        self._version_id = release.version
        self._central_logging_level = 0
        self._element_logging_level = 0
        self._storage_logging_level = 0
        self._health_state = 0
        self._admin_mode = 0
        self._control_mode = 0
        self._simulation_mode = False
        self._test_mode = ""
        #logger.setLevel(logging.DEBUG)

        # create TANGO Groups objects dict, according to property
        self.debug_stream("Groups definitions: {}".format(self.GroupDefinitions))
        try:
            self.groups = get_groups_from_json(self.GroupDefinitions)
            self.info_stream("Groups loaded: {}".format(sorted(self.groups.keys())))
        except GroupDefinitionsError:
            self.info_stream("No Groups loaded for device: {}".format(
                                 self.get_name()))
Example #14
0
 def init_device(self):
     Device.init_device(self)
     self.__tape = {}
     self.__head = 0
     self.__state = self.initial_state
     self.__final_states = []
     self.__transition_function = None
     self.set_state(DevState.RUNNING)
Example #15
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(PfeifferDCU002.init_device) ENABLED START #
     self.ser = serial.Serial(self.SerialPort,
                              9600,
                              bytesize=8,
                              parity="N",
                              stopbits=1)
Example #16
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(WebCam.init_device) ENABLED START #
     pygame.camera.init()
     #pygame.camera.list_cameras()
     self.cam = pygame.camera.Camera(self.webcamdevice,
                                     (self.width, self.height))
     self.cam.start()
Example #17
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(Keithley2100.init_device) ENABLED START #
     #instr=usbtmc.Instrument(idVendor,idProduct)
     self.instr=usbtmc.Instrument(0x05e6,0x2100)
     self.set_status("Connected to DVMM Keithley 2100")
     self.debug_stream("Connected to DVMM Keithley 2100")
     self.set_state(PyTango.DevState.ON)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(RaspberrySwitch.init_device) ENABLED START #
     GPIO.setmode(GPIO.BCM)
     if (self.PullUPorDOWN == True):
         GPIO.setup(self.GPIOport, GPIO.IN, pull_up_down=GPIO.PUD_UP)
     else:
         GPIO.setup(self.GPIOport, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
Example #19
0
 def init_device(self):
     Device.init_device(self)
     self.__tape = {}
     self.__head = 0
     self.__state = self.initial_state
     self.__final_states = []
     self.__transition_function = None
     self.set_state(DevState.RUNNING)
 def set_status(self, status, force=False):
     """Set the status and push events if necessary."""
     with self._exception_lock:
         if force or self.connected:
             Device.set_status(self, status)
         if self.push_events:
             status_attr = self.get_device_attr().get_attr_by_name('Status')
             status_attr.fire_change_event()
Example #21
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(MFC.init_device) ENABLED START #
     self.ser = serial.Serial(self.SerialPort,
                              baudrate=38400,
                              bytesize=8,
                              parity="N",
                              stopbits=1)
     self.set_state(PyTango.DevState.ON)
Example #22
0
 def __init__(self, klass, name):
     self.controller = None              # type: PataraControl
     self.setup_attr_params = dict()
     self.idle_params = dict()
     self.scan_params = dict()
     self.analyse_params = dict()
     self.db = None
     self.state_dispatcher = None    # type: StateDispatcher
     Device.__init__(self, klass, name)
Example #23
0
 def init_device(self):
     Device.init_device(self)
     try:
         self.dyn_attrs_dict = {}
         self.extract_attributes_from_property()
         self.create_dyn_attributes()
     except Exception, e:
         self.set_state(DevState.FAULT)
         self.set_status(e.message)
    def init_device(self):
        Device.init_device(self)
        # PROTECTED REGION ID(ELogSender.init_device) ENABLED START #

        self._entries_que = []
        self._number_of_rejected_entries = 0
        self._total_number_of_rejected_entries = 0
        self.lock = RLock()
        self.set_state(PyTango.DevState.STANDBY)
        self.set_status('No entries in que.')
Example #25
0
 def __init__(self, klass, name):
     self.max_value = 1.0
     self.controller = None              # type: FrogController
     self.setup_attr_params = dict()
     self.idle_params = dict()
     self.scan_params = dict()
     self.analyse_params = dict()
     self.db = None
     self.frogstate_dispatcher = None    # type: FrogStateDispatcher
     Device.__init__(self, klass, name)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(RaspberryButton.init_device) ENABLED START #
     GPIO.setmode(GPIO.BCM)
     GPIO.setup(self.Pin, GPIO.OUT)
     if (self.TrueHigh == True):
         GPIO.output(self.Pin, 0)
     else:
         GPIO.output(self.Pin, 1)
     self.set_state(PyTango.DevState.OFF)
Example #27
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(MKSGauge.init_device) ENABLED START #
     self.ser = serial.Serial(self.SerialPort,
                              baudrate=self.Speed,
                              bytesize=8,
                              parity="N",
                              stopbits=1,
                              timeout=0.5)
     self.set_state(PyTango.DevState.ON)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(LiberaManager.init_device) ENABLED START #
     if self.IncludedLiberas == None:
         self.set_state(DevState.FAULT)
         self.set_status("The IncludedLiberas property isn't filled")
         return
     self.init_thread = threading.Thread(target=self.init_thread)
     self.init_thread.start()
     self.set_state(DevState.INIT)
     self.set_status("LiberaManager initialization started....")
Example #29
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(MCC1208LS.init_device) ENABLED START #
     self.ubox=usb_1208LS.usb_1208LS()
     self.ADC0gain = usb_1208LS.usb_1208LS.BP_10_00V
     self.ADC1gain = usb_1208LS.usb_1208LS.BP_1_00V
     self.ADC0value= 2
     self.ADC1value= 8
     self.set_status("Connected to MCC1208LS")
     self.debug_stream("Connected to MCC1208LS")
     self.set_state(PyTango.DevState.ON)
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(LiberaManager.init_device) ENABLED START #
     if self.IncludedLiberas == None:
         self.set_state(DevState.FAULT)
         self.set_status("The IncludedLiberas property isn't filled")
         return
     self.init_thread = threading.Thread(target=self.init_thread)
     self.init_thread.start()
     self.set_state(DevState.INIT)
     self.set_status("LiberaManager initialization started....")
Example #31
0
    def init_device(self):
        Device.init_device(self)
        self.__always_executed_hook_count = 0
        self.__read_attribute_hardware_count = 0
        self.__write_attribute_counter_count = 0

        self.__scalar_reads_count = 0
        self.__spectrum_reads_count = 0
        self.__image_reads_count = 0
        self.__pipe_reads_count = 0

        self.__scalar_writes_count = 0
        self.__spectrum_writes_count = 0
        self.__image_writes_count = 0
        self.__pipe_writes_count = 0

        self.__command_calls_count = 0

        self.__reset_time = time.time()

        self.__benchmark_scalar_attribute = 0.0
        self.__benchmark_spectrum_attribute = np.zeros(shape=[1024],
                                                       dtype=float)
        self.__benchmark_image_attribute = np.zeros(shape=[1024, 2048],
                                                    dtype=float)

        self.__benchmark_pipe = ('PipeBlob', (
            {
                'name': 'DevLong64',
                'value': 123,
            },
            {
                'name': 'DevULong',
                'value': np.uint32(123)
            },
            {
                'name': 'DevVarUShortArray',
                'value': range(5),
                'dtype': ('uint16', )
            },
            {
                'name': 'DevVarDoubleArray',
                'value': [1.11, 2.22],
                'dtype': ('float64', )
            },
            {
                'name': 'DevBoolean',
                'value': True
            },
        ))

        self.set_change_event("BenchmarkScalarAttribute", True, False)
        self.set_change_event("BenchmarkSpectrumAttribute", True, False)
        self.set_change_event("BenchmarkImageAttribute", True, False)
Example #32
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(HuttingerPFGRF.init_device) ENABLED START #
     self.ser = serial.Serial(self.SerialPort,
                              baudrate=9600,
                              bytesize=8,
                              parity="N",
                              stopbits=1,
                              timeout=0.5)
     (address, command,
      data) = self.parse_response(self.sendcommand(0, "CE", 0))
     self.set_state(PyTango.DevState.OFF)
Example #33
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(GammaIonPump.init_device) ENABLED START #
     self.ser = serial.Serial(self.SerialPort,
                              baudrate=9600,
                              bytesize=8,
                              parity="N",
                              stopbits=1)
     if (self.sendcommand(" 05 61 1 ")[9:-4]) == "YES":
         self.set_state(PyTango.DevState.ON)
     else:
         self.set_state(PyTango.DevState.OFF)
Example #34
0
    def init_device(self):
        Device.init_device(self)
        # PROTECTED REGION ID(PySocket.init_device) ENABLED START #
        self.info_stream('init_device()')

        if not hasattr(self, 'sobj'):
            self.sobj = None
            self.set_change_event('State', True, False)
            self.process_state(DevState.CLOSE)
            self.buffer = ''

        self.info_stream('init_device(): done')
Example #35
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(V4L2Camera.init_device) ENABLED START #
     self.video_capture = cv2.VideoCapture(0)
     if not self.video_capture.isOpened():
         self.set_status("Cannnot connect to camera")
         self.debug_stream("Cannot connet to camera")
         self.set_state(PyTango.DevState.FAULT)
     self.set_status("Connected to camera")
     self.set_state(PyTango.DevState.ON)
     self.video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
     self.video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
Example #36
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(PIDcontroller.init_device) ENABLED START #
     self.kd = 0.0
     self.ki = 0.0
     self.kp = 1.0
     self.ev = 0.0
     self.ev1 = 0.0
     self.ev2 = 0.0
     self.sp = 0.0
     self.last_compute = 0.0
     self.controlled_object = PyTango.DeviceProxy(self.ControlledDeviceProxy)
Example #37
0
    def init_device(self):
        Device.init_device(self)
        self.info_stream('In Python init_device method')
        self.set_state(PyTango.DevState.ON)

        # Attribute initialization
        for joint in self.joints:
            # Filtered
            setattr(self, '_' + joint, (0, 0, 0))
            # Unfiltered
            setattr(self, '_' + joint + "_raw", (0, 0, 0))
        self._moves = (0, 0)
        # Hand status is initilized at True (i.e. open hand)
        self._hand_left_status = True
        self._hand_right_status = True
Example #38
0
    def init_device(self):
        self.__log = logging.getLogger(self.get_name())
        Device.init_device(self)
        self.set_change_event("State", True, True)
        self.set_change_event("Status", True, True)
        self.set_change_event("Position", True, False)
        self.set_change_event("StepSize", True, False)

        switch_state(self, DevState.INIT,
                     "Pending connection to " + self.SpecMotor)

        self.__spec_motor = None
        self.__spec_motor_name = None
        self.__spec_version_name = None
        self.__step_size = 1

        spec_info = find_spec_name(self, self.SpecMotor)
        if spec_info is None:
            return
        spec_version, motor = spec_info
        self.__spec_version_name = spec_version
        self.__spec_motor_name = motor

        cb=dict(connected=self.__motorConnected,
                disconnected=self.__motorDisconnected,
                motorPositionChanged=self.__motorPositionChanged,
                motorStateChanged=self.__motorStateChanged)
                #motorLimitsChanged=self.__motorLimitsChanged)

        try:
            self.__log.debug("Start creating Spec motor %s", motor)
            self.__spec_motor = SpecMotorA(callbacks=cb)
        except SpecClientError as spec_error:
            status = "Error creating Spec motor {0}".format(motor)
            switch_state(self, DevState.FAULT, status)
        else:
            self.__motorConnect()
        self.__log.debug("End creating Spec motor %s", motor)
 def init_device(self):
     Device.init_device(self)
     self.set_change_event("AttributeOkList", True, False)
     self.set_change_event("AttributeNokList", True, False)
     self.set_change_event("AttributeOnList", True, False)
     self.set_change_event("AttributeOffList", True, False)
     self.set_change_event("ArchiverList", True, False)
     self.set_change_event("ArchiverOnList", True, False)
     self.set_change_event("ArchiverOffList", True, False)
     self.set_change_event("AttributeValues", True, False)
     self.set_change_event("AttributeWrongList", True, False)
     self.set_change_event("AttributeLostList", True, False)
     self.set_change_event("AttributeNoevList", True, False)
     self.set_change_event("AttributeStalledList", True, False)
     # PROTECTED REGION ID(SchemaManager.init_device) ENABLED START #
     check_attribute_value.expire = self.CacheTime
     check_attribute_events.expire = self.CacheTime
     self.schema = self.Schemas[0]
     self.api = pyta.api(self.schema)
     self.klass = ''
     self.is_hpp = None
     self.update_time = 0
     self.attributes = []
     self.values = {}
     self.arch_on = []
     self.arch_off = []
     self.attr_on = []
     self.attr_off = []
     self.attr_ok = []
     self.attr_lost = []
     self.attr_nok = []        
     self.attr_err = []
     self.attr_nevs = []
     self.attr_stall = []
     self.UpdateArchivers()
     self.threadDict = self.initThreadDict() if self.Threaded else None
Example #40
0
 def init_device(self):
     Device.init_device(self)
     self.__current = 0.0
     self.set_state(DevState.STANDBY)
 async def init_device(self):
     Device.init_device(self)
     self.proxy = await AttributeProxy(self.Attribute)
     self.set_state(DevState.ON)
Example #42
0
 def init_device(self):
     Device.init_device(self)
Example #43
0
 def init_device(self):
     self.debug_stream("In init_device:")
     Device.init_device(self)
     self.phase_val = 0.0
     self.dac_dev = pt.DeviceProxy(self.dac_ds_name)
     self.set_state(pt.DevState.ON)
Example #44
0
 def delete_device(self):
     Device.delete_device(self)
     for att in self.dyn_attrs_dict.keys():
         listener_name = att + 'Listener'
         self.dyn_attrs_dict[att][0].removeListener(self.__dict__[listener_name])
Example #45
0
 def delete_device(self):
     Device.delete_device(self)
     self.__spec_motor = None
	def init_device(self):
		""" Start device server """
		Device.init_device(self)
		self.reconnect_tries = 0
		self.set_state_ok(DevState.INIT)
		self.board_connect()	# connect to the board
Example #47
0
 def init_device(self):
     Device.init_device(self)
     # PROTECTED REGION ID(ZObject.init_device) ENABLED START #
     self._internal_state = np.array([1.0, 5.0])
     self._matrix = np.array([[0.6, 0.3], [0.3, 0.6]])
     self.set_state(PyTango.DevState.ON)
 def init_device(self):
     Device.init_device(self)
     self.proxy = yield From(AttributeProxy(self.Attribute))
     self.set_state(DevState.ON)
 def get_device_properties(self, cls=None):
     """Raise a ValueError if a property is missing."""
     Device.get_device_properties(self, cls)
     for key, value in self.device_property_list.items():
         if value[2] is None:
             raise ValueError('missing property: ' + key)
Example #50
0
File: CT2.py Project: ESRF-BCU/ct2
 def __init__(self, *args, **kwargs):
     Device.__init__(self, *args, **kwargs)
Example #51
0
 def init_device(self):
     Device.init_device(self)
     self.__coordinates = (0, 0)
     self.set_state(DevState.STANDBY)
Example #52
0
 def __init__(self, *args, **kwargs):
     self.gpib = None
     Device.__init__(self, *args, **kwargs)
Example #53
0
 def init_device(self):
     Device.init_device(self)
     kwargs = dict(url=self.url, pad=self.pad, sad=self.sad,
                   timeout=self.timeout, tmo=self.tmo)
     self.gpib = _Gpib(**kwargs)
     self.gpib.open()
 def dev_state(self):
     """Update attributes and return the state."""
     if not self.push_events:
         self.update_all()
     return Device.dev_state(self)