Debian Codegraph @

pymeasure/instruments/kuhneelectronic/kusg245_250a.py

raw
1 #
2 # This file is part of the PyMeasure package.
3 #
4 # Copyright (c) 2013-2024 PyMeasure Developers
5 #
6 # Permission is hereby granted, free of charge, to any person obtaining a copy
7 # of this software and associated documentation files (the "Software"), to deal
8 # in the Software without restriction, including without limitation the rights
9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 # copies of the Software, and to permit persons to whom the Software is
11 # furnished to do so, subject to the following conditions:
12 #
13 # The above copyright notice and this permission notice shall be included in
14 # all copies or substantial portions of the Software.
15 #
16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 # THE SOFTWARE.
23 #
24
25 import time
26
27 from pymeasure.instruments import Instrument
28 from pymeasure.instruments.validators import truncated_range, truncated_discrete_set
29
30
31 byteorder = 'big'
32 encoding = 'utf-8'
33 termination_character = "\r"
34 reflection_limit_map = {0: 0, 1: 100, 2: 150, 3: 180, 4: 200, 5: 230}
35
36
37 def _has_correct_termination_character(b):
38 return b[-1] == termination_character.encode(encoding=encoding)[0]
39
40
41 def _err_msg_invalid_termination_character(b):
42 return f"Invalid termination character received: {hex(b[-1])}"
43
44
45 def _is_expecting_acknowledgement(command):
46 if command in ["v", "5", "8", "6", "7", "T"]:
47 return False
48 if command.endswith("?"):
49 return False
50 return True
51
52
53 class Kusg245_250A(Instrument):
54 """Represents KU SG 2.45 250 A the 2.45 GHz ISM-Band Microwave Generator
55 and provides a high-level interface for interacting with the instrument.
56
57 :param power_limit: power set-point limit in Watts (integer from 0 to 250).
58 See :attr:`~.Kusg245_250A.power_setpoint`
59 and :meth:`~.Kusg245_250A.tune()`.
60
61 Usage example:
62
63 .. code-block:: python
64
65 from pymeasure.instruments.kuhneelectronic import Kusg245_250A
66
67 generator = Kusg245_250A("ASRL3::INSTR", power_limit=100) # limits the output
68 # power set-point to 100 W
69
70 generator.external_enabled = False # biasing and RF output controlled by serial comm
71 generator.power = 20 # Sets the output power to 20 Watts
72 generator.bias_enabled = True # Enables amplifier biasing
73 generator.rf_enabled = True # Enables the RF output
74
75 p_fwd = generator.power_forward # Reads forward power in Watts
76 p_rev = generator.power_reverse # Reads reflected power in Watts
77 """
78
79 def __init__(self, adapter, name="KU SG 2.45 250 A", power_limit=250, **kwargs):
80 assert 0 < power_limit <= 250, "Param 'power_limit' is out of bounds (0, 250)."
81 super().__init__(adapter,
82 name,
83 asrl={"baud_rate": 115200,
84 "read_termination": termination_character,
85 "write_termination": termination_character},
86 includeSCPI=False,
87 **kwargs)
88
89 self._power_limit = power_limit
90 self.power_setpoint_values = [0, power_limit]
91
92 version = Instrument.measurement("v", """Get firmware version.""")
93
94 @property
95 def voltage_5v(self):
96 """Measure internal 5V supply voltage in Volts."""
97 self.write("5")
98 b = self.read_bytes(3)
99 if _has_correct_termination_character(b):
100 return 103.0 / 4700.0 * int.from_bytes(b[:2], byteorder=byteorder)
101 raise ConnectionError(_err_msg_invalid_termination_character(b))
102
103 @property
104 def voltage_32v(self):
105 """Measure 32V supply voltage in Volts."""
106 self.write("8")
107 b = self.read_bytes(3)
108 if _has_correct_termination_character(b):
109 return 1282.0 / 8200.0 * int.from_bytes(b[:2], byteorder=byteorder)
110 raise ConnectionError(_err_msg_invalid_termination_character(b))
111
112 @property
113 def power_forward(self):
114 """Measure forward power in Watts."""
115 self.write("6")
116 b = self.read_bytes(2)
117 if _has_correct_termination_character(b):
118 return int.from_bytes(b[:1], byteorder=byteorder)
119 raise ConnectionError(_err_msg_invalid_termination_character(b))
120
121 @property
122 def power_reverse(self):
123 """Measure reverse power in Watts."""
124 self.write("7")
125 b = self.read_bytes(2)
126 if _has_correct_termination_character(b):
127 return int.from_bytes(b[:1], byteorder=byteorder)
128 raise ConnectionError(_err_msg_invalid_termination_character(b))
129
130 temperature = Instrument.measurement(
131 "T",
132 """Measure temperature near final transistor in °C."""
133 )
134
135 @property
136 def external_enabled(self):
137 """Control whether amplifier enabling is done
138 via external inputs on 8-pin connector
139 or via serial interface (boolean).
140 """
141 self.write("r?")
142 b = self.read_bytes(2)
143 if _has_correct_termination_character(b):
144 return bool.from_bytes(b[:1], byteorder=byteorder)
145 raise ConnectionError(_err_msg_invalid_termination_character(b))
146
147 @external_enabled.setter
148 def external_enabled(self, value):
149 if value:
150 self.write("R")
151 else:
152 self.write("r")
153
154 @property
155 def bias_enabled(self):
156 """Control whether transistor biasing is enabled (boolean).
157
158 Biasing must be enabled before switching RF on
159 (see :attr:`~.Kusg245_250A.rf_enabled`).
160 """
161 self.write("x?")
162 b = self.read_bytes(2)
163 if _has_correct_termination_character(b):
164 return bool.from_bytes(b[:1], byteorder=byteorder)
165 raise ConnectionError(_err_msg_invalid_termination_character(b))
166
167 @bias_enabled.setter
168 def bias_enabled(self, value):
169 if value:
170 self.write("X")
171 else:
172 self.write("x")
173
174 @property
175 def rf_enabled(self):
176 """Control whether RF output is enabled (boolean).
177
178 .. note::
179
180 Biasing must be enabled before RF is enabled
181 (see :attr:`~.Kusg245_250A.bias_enabled`)
182 """
183 self.write("o?")
184 b = self.read_bytes(2)
185 if _has_correct_termination_character(b):
186 return bool.from_bytes(b[:1], byteorder=byteorder)
187 raise ConnectionError(_err_msg_invalid_termination_character(b))
188
189 @rf_enabled.setter
190 def rf_enabled(self, value):
191 if value:
192 self.write("O")
193 else:
194 self.write("o")
195
196 @property
197 def pulse_mode_enabled(self):
198 """Control whether pulse mode is enabled (boolean).
199
200 .. note::
201
202 Biasing must be enabled before the pulse mode is enabled
203 (see :attr:`~.Kusg245_250A.bias_enabled`)
204 """
205 self.write("p?")
206 b = self.read_bytes(2)
207 if _has_correct_termination_character(b):
208 return bool.from_bytes(b[:1], byteorder=byteorder)
209 raise ConnectionError(_err_msg_invalid_termination_character(b))
210
211 @pulse_mode_enabled.setter
212 def pulse_mode_enabled(self, value):
213 if value:
214 self.write("P")
215 else:
216 self.write("p")
217
218 @property
219 def freq_steps_fine_enabled(self):
220 """Control whether fine frequency steps are enabled (boolean)."""
221 self.write("fm?")
222 b = self.read_bytes(2)
223 if _has_correct_termination_character(b):
224 return bool.from_bytes(b[:1], byteorder=byteorder)
225 raise ConnectionError(_err_msg_invalid_termination_character(b))
226
227 @freq_steps_fine_enabled.setter
228 def freq_steps_fine_enabled(self, value):
229 if value:
230 self.write("fm1")
231 else:
232 self.write("fm0")
233
234 frequency_coarse = Instrument.control(
235 "f?",
236 "f%04d",
237 """Control coarse frequency in MHz (integer from 2400 to 2500).
238
239 Fine frequency mode must be disabled
240 (see :attr:`~.Kusg245_250A.freq_steps_fine_enabled`).
241 Resolution: 1 MHz. Invalid values are truncated.
242 """,
243 validator=truncated_range,
244 values=[2400, 2500],
245 get_process=lambda v: int(v[:-3]) if v.endswith("MHz") else None,
246 )
247
248 frequency_fine = Instrument.control(
249 "f?",
250 "f%07d",
251 """Control fine frequency in kHz (integer from 2400000 to 2500000).
252
253 Fine frequency mode must be enabled
254 (see :attr:`~.Kusg245_250A.freq_steps_fine_enabled`).
255 Resolution: 10 kHz. Invalid values are truncated.
256 Values are rounded to tens.
257 """,
258 validator=truncated_range,
259 values=[2400000, 2500000],
260 set_process=lambda v: round(v, -1),
261 get_process=lambda v: int(v[:-3]) if v.endswith("kHz") else None,
262 )
263
264 power_setpoint = Instrument.control(
265 "A?",
266 "A%03d",
267 """Control output power set-point in Watts (integer from 0 to :attr:`power_limit`
268 parameter - see constructor).
269
270 Resolution: 1 W. Invalid values are truncated.
271 """,
272 validator=truncated_range,
273 values=[0, 250],
274 dynamic=True,
275 )
276
277 pulse_width = Instrument.control(
278 "C?",
279 "C%04d",
280 """Control pulse width in ms (integer from 10 to 1000).
281
282 Resolution: 5 ms. Invalid values are truncated.
283 Values are rounded to multipliers of 5.
284 """,
285 validator=truncated_range,
286 values=[10, 1000],
287 set_process=lambda v: round(2 * v, -1) / 2,
288 )
289
290 off_time = Instrument.control(
291 "c?",
292 "c%04d",
293 """Control off time for the pulse mode in ms (integer from 10 to 1000).
294
295 Resolution: 5 ms. Invalid values are truncated.
296 Values are rounded to multipliers of 5.
297 """,
298 validator=truncated_range,
299 values=[10, 1000],
300 set_process=lambda v: round(2 * v, -1) / 2,
301 )
302
303 @property
304 def phase_shift(self):
305 """Control phase shift in degrees (float from 0 to 358.6).
306
307 Resolution: 8-bits. Values out of range are truncated.
308 """
309 self.write("H?")
310 b = self.read_bytes(2)
311 if _has_correct_termination_character(b):
312 return int.from_bytes(b[:1], byteorder=byteorder) / 256.0 * 360.0
313 raise ConnectionError(_err_msg_invalid_termination_character(b))
314
315 @phase_shift.setter
316 def phase_shift(self, value):
317 value = int(round(truncated_range(value, [0, 358.6])) / 360.0 * 256.0)
318 self.write(f"H{value:03d}")
319
320 @property
321 def reflection_limit(self):
322 """Control limit of reflection in Watts
323 (integer in 0 - no limit, 100, 150, 180, 200, 230).
324
325 .. note::
326
327 If the limit for the reflected power is reached, the forward power
328 is reduced to the specified value and the power control mechanism
329 is locked until the alarm has been cleared by the user via
330 :meth:`~.Kusg245_250A.clear_VSWR_error()`.
331 """
332 self.write("B?")
333 b = self.read_bytes(2)
334 if _has_correct_termination_character(b):
335 return reflection_limit_map[b[0]]
336 raise ConnectionError(_err_msg_invalid_termination_character(b))
337
338 @reflection_limit.setter
339 def reflection_limit(self, value):
340 value = truncated_discrete_set(value, reflection_limit_map.values())
341 inv_reflection_limit_map = {v: k for k, v in reflection_limit_map.items()}
342 value = inv_reflection_limit_map[value]
343 self.write(f"B{value:d}")
344
345 def tune(self, power):
346 """Find and set frequency with lowest reflection
347 at a given power.
348
349 :param power: A power set-point for tuning (in Watts).
350 (integer from 0 to :attr:`power_limit`
351 parameter - see constructor).
352 """
353 power = truncated_range(power, [0, self._power_limit])
354 self.write(f"b{power:03d}")
355
356 def clear_VSWR_error(self):
357 """Clear the VSWR error.
358
359 See: :attr:`~.Kusg245_250A.reflection_limit`.
360 """
361 self.write("z")
362
363 def store_settings(self):
364 """Save actual settings to EEPROM.
365
366 The following parameters are stored:
367 frequency mode (see :attr:`~.Kusg245_250A.freq_steps_fine_enabled`),
368 frequency (see :attr:`~.Kusg245_250A.frequency_coarse`
369 or :attr:`~.Kusg245_250A.frequency_fine`),
370 output power set-point (see :attr:`~.Kusg245_250A.power_setpoint`),
371 ON/OFF control setting (see :attr:`~.Kusg245_250A.external_enabled`),
372 reflection limit (see :attr:`~.Kusg245_250A.reflection_limit`),
373 on time for pulse mode (see :attr:`~.Kusg245_250A.pulse_width`) and
374 off time for pulse mode (see :attr:`~.Kusg245_250A.off_time`).
375 """
376 self.write("SE")
377
378 def turn_off(self):
379 """Safe turn-off the generator.
380
381 1. Disable RF output.
382 2. Deactivate biasing.
383 """
384 self.rf_enabled = False
385 self.bias_enabled = False
386
387 def turn_on(self):
388 """Safe turn-on the generator.
389
390 1. Activate biasing.
391 2. Enable RF output.
392 """
393 self.bias_enabled = True
394 time.sleep(0.500) # not sure if needed
395 self.rf_enabled = True
396
397 def write(self, command, **kwargs):
398 super().write(command, **kwargs)
399 if _is_expecting_acknowledgement(command):
400 s = self.read()
401 if s != "A":
402 raise ConnectionError(f"Expected acknowledgment character 'A'. Received: '{s}'")