| 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}'") |