LaserQuantumLaser - Code Metrics - Inspection of "Merge branch 'master' of https://github.com/Ulm-IQ..." - Ulm-IQO/qudi - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — pulsed_with_queued_connections ( 0b7aaa...175b78 )

unknown

created 2016-10-12 14:59 UTC

LaserQuantumLaser F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	312
Duplicated Lines	0 %

Importance

Changes

Metric	Value
dl	0
loc	312
rs	3.0612
c	0
b	0
f	0
wmc	67

How to fix Complexity

# -*- coding: utf-8 -*-
"""
This module controls LaserQuantum lasers.

Qudi is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Qudi is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Qudi. If not, see <http://www.gnu.org/licenses/>.

Copyright (c) the Qudi Developers. See the COPYRIGHT.txt file at the
top-level directory of this distribution and at <https://github.com/Ulm-IQO/qudi/>
"""

from core.base import Base
from interface.simple_laser_interface import SimpleLaserInterface
from interface.simple_laser_interface import ControlMode
from interface.simple_laser_interface import ShutterState
from interface.simple_laser_interface import LaserState
from enum import Enum
import visa


class PSUTypes(Enum):
    FPU = 0
    MPC6000 = 1
    MPC3000 = 2
    SMD12 = 3
    SMD6000 = 4


class LaserQuantumLaser(Base, SimpleLaserInterface):
    """
    This module implements communication with the Edwards turbopump and
    vacuum equipment.
    """
    _modclass = 'lqlaser'
    _modtype = 'hardware'

    # connectors
    _out = {'laser': 'Laser'}

    def on_activate(self, e):
        """

        @param e:
        @return:
        """
        config = self.getConfiguration()
        self.psu = PSUTypes[config['psu']]
        self.connect_laser(config['interface'])

    def on_deactivate(self, e):
        """
        @param e:
        @return:
        """
        self.disconnect_laser()

    def connect_laser(self, interface):
        """ Connect to Instrument.

            @param str interface: visa interface identifier

            @return bool: connection success
        """
        try:
            self.rm = visa.ResourceManager()
            rate = 9600 if self.psu == PSUTypes.SMD6000 else 19200
            self.inst = self.rm.open_resource(
                interface,
                baud_rate=rate,
                write_termination='\r\n',
                read_termination='\r\n',
                send_end=True)
            self.inst.timeout = 50
        except visa.VisaIOError as e:
            self.log.exception("")
            return False
        else:
            return True

    def disconnect_laser(self):
        """
        Close the connection to the instrument.
        """
        self.inst.close()
        self.rm.close()

    def allowed_control_modes(self):
        """ Control modes for this laser"""
        if self.psu == PSUTypes.FPU:
            return [ControlMode.MIXED]
        elif self.psu == PSUTypes.SMD6000:
            return [ControlMode.POWER]
        else:
            return [ControlMode.POWER, ControlMode.CURRENT]

    def get_control_mode(self):
        """

        @return:
        """
        if self.psu == PSUTypes.FPU:
            return ControlMode.MIXED
        elif self.psu == PSUTypes.SMD6000:
            return ControlMode.POWER
        else:
            return ControlMode[self.inst.query('CONTROL?')]

    def set_control_mode(self, mode):
        """

        @param mode:
        @return:
        """
        if self.psu == PSUTypes.FPU:
            return ControlMode.MIXED
        elif self.psu == PSUTypes.SMD6000:
            return ControlMode.POWER.
        else:
            if mode == ControlMode.POWER:
                self.inst.query('PFB=OFF')
                self.inst.query('CONTROL=POWER')
            else:
                self.inst.query('PFB=ON')
                self.inst.query('CONTROL=CURRENT')
        return self.get_control_mode()

    def get_power(self):
        """

        @return:
        """
        answer = self.inst.query('POWER?')
        if "mW" in answer:
            return float(answer.split('mW')[0])/1000
        elif 'W' in answer:
            return float(answer.split('W')[0])
        else:
            return float(answer)

    def get_power_setpoint(self):
        """

        @return:
        """
        if self.psu != PSUTypes.SMD6000:
            answer = self.inst.query('SETPOWER?')
            if "mW" in answer:
                return float(answer.split('mW')[0]) / 1000
            elif 'W' in answer:
                return float(answer.split('W')[0])
            else:
                return float(answer)
        else:
            return self.get_power()

    def set_power_setpoint(self, power):
        """

        @param power:
        @return:
        """
        if self.psu == PSUTypes.FPU:
            self.inst.query('POWER={0:f}'.format(power))
        else:
            self.inst.query('POWER={0:f}'.format(power*1000))

    def get_current(self):
        """

        @return:
        """
        if self.psu == PSUTypes.MPC3000 or self.psu == PSUTypes.MPC6000:
            return float(self.inst.query('SETCURRENT1?').split('%')[0])
        else:
            return float(self.inst.query('CURRENT?').split('%')[0])

    def get_current_setpoint(self):
        """

        @return:
        """
        if self.psu == PSUTypes.MPC3000 or self.psu == PSUTypes.MPC6000:
            return float(self.inst.query('SETCURRENT1?').split('%')[0])
        else:
            return float(self.inst.query('SETCURRENT?').split('%')[0])

    def set_current(self, current_percent):
        """

        @param current_percent:
        @return:
        """
        self.inst.query('CURRENT={0}'.format(current_percent))
        return self.get_current()

    def get_shutter_state(self):
        """

        @return:
        """
        if self.psu == PSUTypes.FPU:
            state = self.inst.query('SHUTTER?')
            if 'OPEN' in state:
                return ShutterState.OPEN
            elif 'CLOSED' in state:
                return ShutterState.CLOSED
            else:
                return ShutterState.UNKNOWN
        else:
            return ShutterState.NOSHUTTER

    def set_shutter_state(self, state):
        """

        @param state:
        @return:
        """
        if self.psu == PSUTypes.FPU:
            actstate = self.get_shutter_state()
            if state != actstate:
                if state == ShutterState.OPEN:
                    self.inst.query('SHUTTER OPEN')
                elif state == ShutterState.CLOSED:
                    self.inst.query('SHUTTER CLOSE')
        return self.get_shutter_state()

    def get_psu_temperature(self):
        """

        @return:
        """
        return float(self.inst.query('PSUTEMP?').split('C')[0])

    def get_laser_temperature(self):
        """

        @return:
        """
        return float(self.inst.query('LASTEMP?').split('C')[0])

    def get_temperatures(self):
        return {
            'psu': self.get_psu_temperature(),
            'laser': self.get_laser_temperature()
            }

    def set_temperatures(self, temps):
        return {}

    def get_lcd(self):
        """

        @return:
        """
        if self.psu == PSUTypes.SMD12 or self.psu == PSUTypes.SMD6000:
            return ''
        else:
            return self.inst.query('STATUSLCD?')

    def get_laser_state(self):
        """

        @return:
        """
        if self.psu == PSUTypes.SMD6000:
            state = self.inst.query('STAT?')
        else:
            state = self.inst.query('STATUS?')
        if 'ENABLED' in state:
            return LaserState.ON
        elif 'DISABLED' in state:
            return LaserState.OFF
        else:
            return LaserState.UNKNOWN

    def set_laser_state(self, status):
        """

        @param status:
        @return:
        """
        actstat = self.get_laser_state()
        if actstat != status:
            if status == LaserState.ON:
                self.inst.query('ON')
            elif status == LaserState.OFF:
                self.inst.query('OFF')
        return self.get_laser_state()

    def on(self):
        return self.set_laser_state(LaserState.ON)

    def off(self):
        return self.set_laser_state(LaserState.OFF)

    def get_firmware_version(self):
        """ Ask the laser for ID.

        @return str: what the laser tells you about itself
        """
        if self.psu == PSUTypes.SMD6000:
            self.inst.write('VERSION')
        else:
            self.inst.write('SOFTVER?')
        lines = []
        try:
            while True:
                lines.append(self.inst.read())
        except:
            pass
        return lines

    def dump(self):
        """

        @return:
        """
        self.inst.write('DUMP ')
        lines = []
        try:
            while True:
                lines.append(self.inst.read())
        except:
            pass
        return lines

    def timers(self):
        """

        @return:
        """
        self.inst.write('TIMERS')
        lines = []
        try:
            while True:
                lines.append(self.inst.read())
        except:
            pass
        return lines

    def get_extra_info(self):
        extra = ''
        extra += '\n'.join(self.get_firmware_version())
        extra += '\n'
        extra += '\n'.join(self.dump())
        extra += '\n'
        extra += '\n'.join(self.timers())
        extra += '\n'
        return extra



1			# -- coding: utf-8 --
2			"""
3			This module controls LaserQuantum lasers.
4
5			Qudi is free software: you can redistribute it and/or modify
6			it under the terms of the GNU General Public License as published by
7			the Free Software Foundation, either version 3 of the License, or
8			(at your option) any later version.
9
10			Qudi is distributed in the hope that it will be useful,
11			but WITHOUT ANY WARRANTY; without even the implied warranty of
12			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			GNU General Public License for more details.
14
15			You should have received a copy of the GNU General Public License
16			along with Qudi. If not, see <http://www.gnu.org/licenses/>.
17
18			Copyright (c) the Qudi Developers. See the COPYRIGHT.txt file at the
19			top-level directory of this distribution and at <https://github.com/Ulm-IQO/qudi/>
20			"""
21
22			from core.base import Base
23			from interface.simple_laser_interface import SimpleLaserInterface
24			from interface.simple_laser_interface import ControlMode
25			from interface.simple_laser_interface import ShutterState
26			from interface.simple_laser_interface import LaserState
27			from enum import Enum
28			import visa
29
30
31			class PSUTypes(Enum):
32			FPU = 0
33			MPC6000 = 1
34			MPC3000 = 2
35			SMD12 = 3
36			SMD6000 = 4
37
38
39			class LaserQuantumLaser(Base, SimpleLaserInterface):
40			"""
41			This module implements communication with the Edwards turbopump and
42			vacuum equipment.
43			"""
44			_modclass = 'lqlaser'
45			_modtype = 'hardware'
46
47			# connectors
48			_out = {'laser': 'Laser'}
49
50			def on_activate(self, e):
51			"""
52
53			@param e:
54			@return:
55			"""
56			config = self.getConfiguration()
57			self.psu = PSUTypes[config['psu']]
58			self.connect_laser(config['interface'])
59
60			def on_deactivate(self, e):
61			"""
62			@param e:
63			@return:
64			"""
65			self.disconnect_laser()
66
67			def connect_laser(self, interface):
68			""" Connect to Instrument.
69
70			@param str interface: visa interface identifier
71
72			@return bool: connection success
73			"""
74			try:
75			self.rm = visa.ResourceManager()
76			rate = 9600 if self.psu == PSUTypes.SMD6000 else 19200
77			self.inst = self.rm.open_resource(
78			interface,
79			baud_rate=rate,
80			write_termination='\r\n',
81			read_termination='\r\n',
82			send_end=True)
83			self.inst.timeout = 50
84			except visa.VisaIOError as e:
85			self.log.exception("")
86			return False
87			else:
88			return True
89
90			def disconnect_laser(self):
91			"""
92			Close the connection to the instrument.
93			"""
94			self.inst.close()
95			self.rm.close()
96
97			def allowed_control_modes(self):
98			""" Control modes for this laser"""
99			if self.psu == PSUTypes.FPU:
100			return [ControlMode.MIXED]
101			elif self.psu == PSUTypes.SMD6000:
102			return [ControlMode.POWER]
103			else:
104			return [ControlMode.POWER, ControlMode.CURRENT]
105
106			def get_control_mode(self):
107			"""
108
109			@return:
110			"""
111			if self.psu == PSUTypes.FPU:
112			return ControlMode.MIXED
113			elif self.psu == PSUTypes.SMD6000:
114			return ControlMode.POWER
115			else:
116			return ControlMode[self.inst.query('CONTROL?')]
117
118			def set_control_mode(self, mode):
119			"""
120
121			@param mode:
122			@return:
123			"""
124			if self.psu == PSUTypes.FPU:
125			return ControlMode.MIXED
126			elif self.psu == PSUTypes.SMD6000:
127			return ControlMode.POWER.
128			else:
129			if mode == ControlMode.POWER:
130			self.inst.query('PFB=OFF')
131			self.inst.query('CONTROL=POWER')
132			else:
133			self.inst.query('PFB=ON')
134			self.inst.query('CONTROL=CURRENT')
135			return self.get_control_mode()
136
137			def get_power(self):
138			"""
139
140			@return:
141			"""
142			answer = self.inst.query('POWER?')
143			if "mW" in answer:
144			return float(answer.split('mW')[0])/1000
145			elif 'W' in answer:
146			return float(answer.split('W')[0])
147			else:
148			return float(answer)
149
150			def get_power_setpoint(self):
151			"""
152
153			@return:
154			"""
155			if self.psu != PSUTypes.SMD6000:
156			answer = self.inst.query('SETPOWER?')
157			if "mW" in answer:
158			return float(answer.split('mW')[0]) / 1000
159			elif 'W' in answer:
160			return float(answer.split('W')[0])
161			else:
162			return float(answer)
163			else:
164			return self.get_power()
165
166			def set_power_setpoint(self, power):
167			"""
168
169			@param power:
170			@return:
171			"""
172			if self.psu == PSUTypes.FPU:
173			self.inst.query('POWER={0:f}'.format(power))
174			else:
175			self.inst.query('POWER={0:f}'.format(power*1000))
176
177			def get_current(self):
178			"""
179
180			@return:
181			"""
182			if self.psu == PSUTypes.MPC3000 or self.psu == PSUTypes.MPC6000:
183			return float(self.inst.query('SETCURRENT1?').split('%')[0])
184			else:
185			return float(self.inst.query('CURRENT?').split('%')[0])
186
187			def get_current_setpoint(self):
188			"""
189
190			@return:
191			"""
192			if self.psu == PSUTypes.MPC3000 or self.psu == PSUTypes.MPC6000:
193			return float(self.inst.query('SETCURRENT1?').split('%')[0])
194			else:
195			return float(self.inst.query('SETCURRENT?').split('%')[0])
196
197			def set_current(self, current_percent):
198			"""
199
200			@param current_percent:
201			@return:
202			"""
203			self.inst.query('CURRENT={0}'.format(current_percent))
204			return self.get_current()
205
206			def get_shutter_state(self):
207			"""
208
209			@return:
210			"""
211			if self.psu == PSUTypes.FPU:
212			state = self.inst.query('SHUTTER?')
213			if 'OPEN' in state:
214			return ShutterState.OPEN
215			elif 'CLOSED' in state:
216			return ShutterState.CLOSED
217			else:
218			return ShutterState.UNKNOWN
219			else:
220			return ShutterState.NOSHUTTER
221
222			def set_shutter_state(self, state):
223			"""
224
225			@param state:
226			@return:
227			"""
228			if self.psu == PSUTypes.FPU:
229			actstate = self.get_shutter_state()
230			if state != actstate:
231			if state == ShutterState.OPEN:
232			self.inst.query('SHUTTER OPEN')
233			elif state == ShutterState.CLOSED:
234			self.inst.query('SHUTTER CLOSE')
235			return self.get_shutter_state()
236
237			def get_psu_temperature(self):
238			"""
239
240			@return:
241			"""
242			return float(self.inst.query('PSUTEMP?').split('C')[0])
243
244			def get_laser_temperature(self):
245			"""
246
247			@return:
248			"""
249			return float(self.inst.query('LASTEMP?').split('C')[0])
250
251			def get_temperatures(self):
252			return {
253			'psu': self.get_psu_temperature(),
254			'laser': self.get_laser_temperature()
255			}
256
257			def set_temperatures(self, temps):
258			return {}
259
260			def get_lcd(self):
261			"""
262
263			@return:
264			"""
265			if self.psu == PSUTypes.SMD12 or self.psu == PSUTypes.SMD6000:
266			return ''
267			else:
268			return self.inst.query('STATUSLCD?')
269
270			def get_laser_state(self):
271			"""
272
273			@return:
274			"""
275			if self.psu == PSUTypes.SMD6000:
276			state = self.inst.query('STAT?')
277			else:
278			state = self.inst.query('STATUS?')
279			if 'ENABLED' in state:
280			return LaserState.ON
281			elif 'DISABLED' in state:
282			return LaserState.OFF
283			else:
284			return LaserState.UNKNOWN
285
286			def set_laser_state(self, status):
287			"""
288
289			@param status:
290			@return:
291			"""
292			actstat = self.get_laser_state()
293			if actstat != status:
294			if status == LaserState.ON:
295			self.inst.query('ON')
296			elif status == LaserState.OFF:
297			self.inst.query('OFF')
298			return self.get_laser_state()
299
300			def on(self):
301			return self.set_laser_state(LaserState.ON)
302
303			def off(self):
304			return self.set_laser_state(LaserState.OFF)
305
306			def get_firmware_version(self):
307			""" Ask the laser for ID.
308
309			@return str: what the laser tells you about itself
310			"""
311			if self.psu == PSUTypes.SMD6000:
312			self.inst.write('VERSION')
313			else:
314			self.inst.write('SOFTVER?')
315			lines = []
316			try:
317			while True:
318			lines.append(self.inst.read())
319			except:
320			pass
321			return lines
322
323			def dump(self):
324			"""
325
326			@return:
327			"""
328			self.inst.write('DUMP ')
329			lines = []
330			try:
331			while True:
332			lines.append(self.inst.read())
333			except:
334			pass
335			return lines
336
337			def timers(self):
338			"""
339
340			@return:
341			"""
342			self.inst.write('TIMERS')
343			lines = []
344			try:
345			while True:
346			lines.append(self.inst.read())
347			except:
348			pass
349			return lines
350
351			def get_extra_info(self):
352			extra = ''
353			extra += '\n'.join(self.get_firmware_version())
354			extra += '\n'
355			extra += '\n'.join(self.dump())
356			extra += '\n'
357			extra += '\n'.join(self.timers())
358			extra += '\n'
359			return extra
360
361

Ulm-IQO / qudi

Push — pulsed_with_queued_connections ( 0b7aaa...175b78 )

LaserQuantumLaser F

Complexity

Size/Duplication

Importance

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like