1 #/usr/bin/env python3.4 2 # 3 # Copyright 2016 - The Android Open Source Project 4 # 5 # Licensed under the Apache License, Version 2.0 (the "License"); 6 # you may not use this file except in compliance with the License. 7 # You may obtain a copy of the License at 8 # 9 # http://www.apache.org/licenses/LICENSE-2.0 10 # 11 # Unless required by applicable law or agreed to in writing, software 12 # distributed under the License is distributed on an "AS IS" BASIS, 13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 # See the License for the specific language governing permissions and 15 # limitations under the License. 16 """ 17 Controller interface for Anritsu Signal Generator MG3710A. 18 """ 19 20 import time 21 import socket 22 from enum import Enum 23 from enum import IntEnum 24 25 from acts.controllers.anritsu_lib._anritsu_utils import AnritsuError 26 from acts.controllers.anritsu_lib._anritsu_utils import NO_ERROR 27 from acts.controllers.anritsu_lib._anritsu_utils import OPERATION_COMPLETE 28 29 TERMINATOR = "\n" 30 31 32 def create(configs, logger): 33 objs = [] 34 for c in configs: 35 ip_address = c["ip_address"] 36 objs.append(MG3710A(ip_address, logger)) 37 return objs 38 39 40 def destroy(objs): 41 return 42 43 44 class MG3710A(object): 45 """Class to communicate with Anritsu Signal Generator MG3710A. 46 This uses GPIB command to interface with Anritsu MG3710A """ 47 48 def __init__(self, ip_address, log_handle): 49 self._ipaddr = ip_address 50 self.log = log_handle 51 52 # Open socket connection to Signaling Tester 53 self.log.info("Opening Socket Connection with " 54 "Signal Generator MG3710A ({}) ".format(self._ipaddr)) 55 try: 56 self._sock = socket.create_connection( 57 (self._ipaddr, 49158), timeout=30) 58 self.send_query("*IDN?", 60) 59 self.log.info("Communication Signal Generator MG3710A OK.") 60 self.log.info("Opened Socket connection to ({})" 61 "with handle ({})".format(self._ipaddr, self._sock)) 62 except socket.timeout: 63 raise AnritsuError("Timeout happened while conencting to" 64 " Anritsu MG3710A") 65 except socket.error: 66 raise AnritsuError("Socket creation error") 67 68 def disconnect(self): 69 """ Disconnect Signal Generator MG3710A 70 71 Args: 72 None 73 74 Returns: 75 None 76 """ 77 self.send_command(":SYST:COMM:GTL", opc=False) 78 self._sock.close() 79 80 def send_query(self, query, sock_timeout=10): 81 """ Sends a Query message to Anritsu MG3710A and return response 82 83 Args: 84 query - Query string 85 86 Returns: 87 query response 88 """ 89 self.log.info("--> {}".format(query)) 90 querytoSend = (query + TERMINATOR).encode('utf-8') 91 self._sock.settimeout(sock_timeout) 92 try: 93 self._sock.send(querytoSend) 94 result = self._sock.recv(256).rstrip(TERMINATOR.encode('utf-8')) 95 response = result.decode('utf-8') 96 self.log.info('<-- {}'.format(response)) 97 return response 98 except socket.timeout: 99 raise AnritsuError("Timeout: Response from Anritsu") 100 except socket.error: 101 raise AnritsuError("Socket Error") 102 103 def send_command(self, command, sock_timeout=30, opc=True): 104 """ Sends a Command message to Anritsu MG3710A 105 106 Args: 107 command - command string 108 109 Returns: 110 None 111 """ 112 self.log.info("--> {}".format(command)) 113 cmdToSend = (command + TERMINATOR).encode('utf-8') 114 self._sock.settimeout(sock_timeout) 115 try: 116 self._sock.send(cmdToSend) 117 if opc: 118 # check operation status 119 status = self.send_query("*OPC?") 120 if int(status) != OPERATION_COMPLETE: 121 raise AnritsuError("Operation not completed") 122 except socket.timeout: 123 raise AnritsuError("Timeout for Command Response from Anritsu") 124 except socket.error: 125 raise AnritsuError("Socket Error for Anritsu command") 126 return 127 128 @property 129 def sg(self): 130 """ Gets current selected signal generator(SG) 131 132 Args: 133 None 134 135 Returns: 136 selected signal generatr number 137 """ 138 return self.send_query("PORT?") 139 140 @sg.setter 141 def sg(self, sg_number): 142 """ Selects the signal generator to be controlled 143 144 Args: 145 sg_number: sg number 1 | 2 146 147 Returns: 148 None 149 """ 150 cmd = "PORT {}".format(sg_number) 151 self.send_command(cmd) 152 153 def get_modulation_state(self, sg=1): 154 """ Gets the RF signal modulation state (ON/OFF) of signal generator 155 156 Args: 157 sg: signal generator number. 158 Default is 1 159 160 Returns: 161 modulation state . 0 (OFF) | 1(ON) 162 """ 163 return self.send_query("OUTP{}:MOD?".format(sg)) 164 165 def set_modulation_state(self, state, sg=1): 166 """ Sets the RF signal modulation state 167 168 Args: 169 sg: signal generator number. 170 Default is 1 171 state : ON/OFF 172 173 Returns: 174 None 175 """ 176 cmd = "OUTP{}:MOD {}".format(sg, state) 177 self.send_command(cmd) 178 179 def get_rf_output_state(self, sg=1): 180 """ Gets RF signal output state (ON/OFF) of signal generator 181 182 Args: 183 sg: signal generator number. 184 Default is 1 185 186 Returns: 187 RF signal output state . 0 (OFF) | 1(ON) 188 """ 189 return self.send_query("OUTP{}?".format(sg)) 190 191 def set_rf_output_state(self, state, sg=1): 192 """ Sets the RF signal output state 193 194 Args: 195 sg: signal generator number. 196 Default is 1 197 state : ON/OFF 198 199 Returns: 200 None 201 """ 202 cmd = "OUTP{} {}".format(sg, state) 203 self.send_command(cmd) 204 205 def get_frequency(self, sg=1): 206 """ Gets the selected frequency of signal generator 207 208 Args: 209 sg: signal generator number. 210 Default is 1 211 212 Returns: 213 selected frequency 214 """ 215 return self.send_query("SOUR{}:FREQ?".format(sg)) 216 217 def set_frequency(self, freq, sg=1): 218 """ Sets the frequency of signal generator 219 220 Args: 221 sg: signal generator number. 222 Default is 1 223 freq : frequency 224 225 Returns: 226 None 227 """ 228 cmd = "SOUR{}:FREQ {}".format(sg, freq) 229 self.send_command(cmd) 230 231 def get_frequency_offset_state(self, sg=1): 232 """ Gets the Frequency Offset enable state (ON/OFF) of signal generator 233 234 Args: 235 sg: signal generator number. 236 Default is 1 237 238 Returns: 239 Frequency Offset enable state . 0 (OFF) | 1(ON) 240 """ 241 return self.send_query("SOUR{}:FREQ:OFFS:STAT?".format(sg)) 242 243 def set_frequency_offset_state(self, state, sg=1): 244 """ Sets the Frequency Offset enable state 245 246 Args: 247 sg: signal generator number. 248 Default is 1 249 state : enable state, ON/OFF 250 251 Returns: 252 None 253 """ 254 cmd = "SOUR{}:FREQ:OFFS:STAT {}".format(sg, state) 255 self.send_command(cmd) 256 257 def get_frequency_offset(self, sg=1): 258 """ Gets the current frequency offset value 259 260 Args: 261 sg: signal generator number. 262 Default is 1 263 264 Returns: 265 current frequency offset value 266 """ 267 return self.send_query("SOUR{}:FREQ:OFFS?".format(sg)) 268 269 def set_frequency_offset(self, offset, sg=1): 270 """ Sets the frequency offset value 271 272 Args: 273 sg: signal generator number. 274 Default is 1 275 offset : frequency offset value 276 277 Returns: 278 None 279 """ 280 cmd = "SOUR{}:FREQ:OFFS {}".format(sg, offset) 281 self.send_command(cmd) 282 283 def get_frequency_offset_multiplier_state(self, sg=1): 284 """ Gets the Frequency Offset multiplier enable state (ON/OFF) of 285 signal generator 286 287 Args: 288 sg: signal generator number. 289 Default is 1 290 291 Returns: 292 Frequency Offset multiplier enable state . 0 (OFF) | 1(ON) 293 """ 294 return self.send_query("SOUR{}:FREQ:MULT:STAT?".format(sg)) 295 296 def set_frequency_offset_multiplier_state(self, state, sg=1): 297 """ Sets the Frequency Offset multiplier enable state 298 299 Args: 300 sg: signal generator number. 301 Default is 1 302 state : enable state, ON/OFF 303 304 Returns: 305 None 306 """ 307 cmd = "SOUR{}:FREQ:MULT:STAT {}".format(sg, state) 308 self.send_command(cmd) 309 310 def get_frequency_offset_multiplier(self, sg=1): 311 """ Gets the current frequency offset multiplier value 312 313 Args: 314 sg: signal generator number. 315 Default is 1 316 317 Returns: 318 frequency offset multiplier value 319 """ 320 return self.send_query("SOUR{}:FREQ:MULT?".format(sg)) 321 322 def set_frequency_offset_multiplier(self, multiplier, sg=1): 323 """ Sets the frequency offset multiplier value 324 325 Args: 326 sg: signal generator number. 327 Default is 1 328 multiplier : frequency offset multiplier value 329 330 Returns: 331 None 332 """ 333 cmd = "SOUR{}:FREQ:MULT {}".format(sg, multiplier) 334 self.send_command(cmd) 335 336 def get_channel(self, sg=1): 337 """ Gets the current channel number 338 339 Args: 340 sg: signal generator number. 341 Default is 1 342 343 Returns: 344 current channel number 345 """ 346 return self.send_query("SOUR{}:FREQ:CHAN:NUMB?".format(sg)) 347 348 def set_channel(self, channel, sg=1): 349 """ Sets the channel number 350 351 Args: 352 sg: signal generator number. 353 Default is 1 354 channel : channel number 355 356 Returns: 357 None 358 """ 359 cmd = "SOUR{}:FREQ:CHAN:NUMB {}".format(sg, channel) 360 self.send_command(cmd) 361 362 def get_channel_group(self, sg=1): 363 """ Gets the current channel group number 364 365 Args: 366 sg: signal generator number. 367 Default is 1 368 369 Returns: 370 current channel group number 371 """ 372 return self.send_query("SOUR{}:FREQ:CHAN:GRO?".format(sg)) 373 374 def set_channel_group(self, group, sg=1): 375 """ Sets the channel group number 376 377 Args: 378 sg: signal generator number. 379 Default is 1 380 group : channel group number 381 382 Returns: 383 None 384 """ 385 cmd = "SOUR{}:FREQ:CHAN:GRO {}".format(sg, group) 386 self.send_command(cmd) 387 388 def get_rf_output_level(self, sg=1): 389 """ Gets the current RF output level 390 391 Args: 392 sg: signal generator number. 393 Default is 1 394 395 Returns: 396 current RF output level 397 """ 398 return self.send_query("SOUR{}:POW:CURR?".format(sg)) 399 400 def get_output_level_unit(self, sg=1): 401 """ Gets the current RF output level unit 402 403 Args: 404 sg: signal generator number. 405 Default is 1 406 407 Returns: 408 current RF output level unit 409 """ 410 return self.send_query("UNIT{}:POW?".format(sg)) 411 412 def set_output_level_unit(self, unit, sg=1): 413 """ Sets the RF output level unit 414 415 Args: 416 sg: signal generator number. 417 Default is 1 418 unit : Output level unit 419 420 Returns: 421 None 422 """ 423 cmd = "UNIT{}:POW {}".format(sg, unit) 424 self.send_command(cmd) 425 426 def get_output_level(self, sg=1): 427 """ Gets the Output level 428 429 Args: 430 sg: signal generator number. 431 Default is 1 432 433 Returns: 434 Output level 435 """ 436 return self.send_query("SOUR{}:POW?".format(sg)) 437 438 def set_output_level(self, level, sg=1): 439 """ Sets the Output level 440 441 Args: 442 sg: signal generator number. 443 Default is 1 444 level : Output level 445 446 Returns: 447 None 448 """ 449 cmd = "SOUR{}:POW {}".format(sg, level) 450 self.send_command(cmd) 451 452 def get_arb_state(self, sg=1): 453 """ Gets the ARB function state 454 455 Args: 456 sg: signal generator number. 457 Default is 1 458 459 Returns: 460 ARB function state . 0 (OFF) | 1(ON) 461 """ 462 return self.send_query("SOUR{}:RAD:ARB?".format(sg)) 463 464 def set_arb_state(self, state, sg=1): 465 """ Sets the ARB function state 466 467 Args: 468 sg: signal generator number. 469 Default is 1 470 state : enable state (ON/OFF) 471 472 Returns: 473 None 474 """ 475 cmd = "SOUR{}:RAD:ARB {}".format(sg, state) 476 self.send_command(cmd) 477 478 def restart_arb_waveform_pattern(self, sg=1): 479 """ playback the waveform pattern from the beginning. 480 481 Args: 482 sg: signal generator number. 483 Default is 1 484 485 Returns: 486 None 487 """ 488 cmd = "SOUR{}:RAD:ARB:WAV:REST".format(sg) 489 self.send_command(cmd) 490 491 def load_waveform(self, package_name, pattern_name, memory, sg=1): 492 """ loads the waveform from HDD to specified memory 493 494 Args: 495 sg: signal generator number. 496 Default is 1 497 package_name : Package name of signal 498 pattern_name : Pattern name of signal 499 memory: memory for the signal - "A" or "B" 500 501 Returns: 502 None 503 """ 504 cmd = "MMEM{}:LOAD:WAV:WM{} '{}','{}'".format(sg, memory, package_name, 505 pattern_name) 506 self.send_command(cmd) 507 508 def select_waveform(self, package_name, pattern_name, memory, sg=1): 509 """ Selects the waveform to output on specified memory 510 511 Args: 512 sg: signal generator number. 513 Default is 1 514 package_name : Package name of signal 515 pattern_name : Pattern name of signal 516 memory: memory for the signal - "A" or "B" 517 518 Returns: 519 None 520 """ 521 cmd = "SOUR{}:RAD:ARB:WM{}:WAV '{}','{}'".format( 522 sg, memory, package_name, pattern_name) 523 self.send_command(cmd) 524 525 def get_freq_relative_display_status(self, sg=1): 526 """ Gets the frequency relative display status 527 528 Args: 529 sg: signal generator number. 530 Default is 1 531 532 Returns: 533 frequency relative display status. 0 (OFF) | 1(ON) 534 """ 535 return self.send_query("SOUR{}:FREQ:REF:STAT?".format(sg)) 536 537 def set_freq_relative_display_status(self, enable, sg=1): 538 """ Sets frequency relative display status 539 540 Args: 541 sg: signal generator number. 542 Default is 1 543 enable : enable type (ON/OFF) 544 545 Returns: 546 None 547 """ 548 cmd = "SOUR{}:FREQ:REF:STAT {}".format(sg, enable) 549 self.send_command(cmd) 550 551 def get_freq_channel_display_type(self, sg=1): 552 """ Gets the selected type(frequency/channel) for input display 553 554 Args: 555 sg: signal generator number. 556 Default is 1 557 558 Returns: 559 selected type(frequecy/channel) for input display 560 """ 561 return self.send_query("SOUR{}:FREQ:TYPE?".format(sg)) 562 563 def set_freq_channel_display_type(self, freq_channel, sg=1): 564 """ Sets thes type(frequency/channel) for input display 565 566 Args: 567 sg: signal generator number. 568 Default is 1 569 freq_channel : display type (frequency/channel) 570 571 Returns: 572 None 573 """ 574 cmd = "SOUR{}:FREQ:TYPE {}".format(sg, freq_channel) 575 self.send_command(cmd) 576 577 def get_arb_combination_mode(self, sg=1): 578 """ Gets the current mode to generate the pattern 579 580 Args: 581 sg: signal generator number. 582 Default is 1 583 584 Returns: 585 current mode to generate the pattern 586 """ 587 return self.send_query("SOUR{}:RAD:ARB:PCOM?".format(sg)) 588 589 def set_arb_combination_mode(self, mode, sg=1): 590 """ Sets the mode to generate the pattern 591 592 Args: 593 sg: signal generator number. 594 Default is 1 595 mode : pattern generation mode 596 597 Returns: 598 None 599 """ 600 cmd = "SOUR{}:RAD:ARB:PCOM {}".format(sg, mode) 601 self.send_command(cmd) 602 603 def get_arb_pattern_aorb_state(self, a_or_b, sg=1): 604 """ Gets the Pattern A/B output state 605 606 Args: 607 sg: signal generator number. 608 Default is 1 609 a_or_b : Patten A or Pattern B( "A" or "B") 610 611 Returns: 612 Pattern A/B output state . 0(OFF) | 1(ON) 613 """ 614 return self.send_query("SOUR{}:RAD:ARB:WM{}:OUTP?".format(a_or_b, sg)) 615 616 def set_arb_pattern_aorb_state(self, a_or_b, state, sg=1): 617 """ Sets the Pattern A/B output state 618 619 Args: 620 sg: signal generator number. 621 Default is 1 622 a_or_b : Patten A or Pattern B( "A" or "B") 623 state : output state 624 625 Returns: 626 None 627 """ 628 cmd = "SOUR{}:RAD:ARB:WM{}:OUTP {}".format(sg, a_or_b, state) 629 self.send_command(cmd) 630 631 def get_arb_level_aorb(self, a_or_b, sg=1): 632 """ Gets the Pattern A/B output level 633 634 Args: 635 sg: signal generator number. 636 Default is 1 637 a_or_b : Patten A or Pattern B( "A" or "B") 638 639 Returns: 640 Pattern A/B output level 641 """ 642 return self.send_query("SOUR{}:RAD:ARB:WM{}:POW?".format(sg, a_or_b)) 643 644 def set_arb_level_aorb(self, a_or_b, level, sg=1): 645 """ Sets the Pattern A/B output level 646 647 Args: 648 sg: signal generator number. 649 Default is 1 650 a_or_b : Patten A or Pattern B( "A" or "B") 651 level : output level 652 653 Returns: 654 None 655 """ 656 cmd = "SOUR{}:RAD:ARB:WM{}:POW {}".format(sg, a_or_b, level) 657 self.send_command(cmd) 658 659 def get_arb_freq_offset(self, sg=1): 660 """ Gets the frequency offset between Pattern A and Patten B 661 when CenterSignal is A or B. 662 663 Args: 664 sg: signal generator number. 665 Default is 1 666 667 Returns: 668 frequency offset between Pattern A and Patten B 669 """ 670 return self.send_query("SOUR{}:RAD:ARB:FREQ:OFFS?".format(sg)) 671 672 def set_arb_freq_offset(self, offset, sg=1): 673 """ Sets the frequency offset between Pattern A and Patten B when 674 CenterSignal is A or B. 675 676 Args: 677 sg: signal generator number. 678 Default is 1 679 offset : frequency offset 680 681 Returns: 682 None 683 """ 684 cmd = "SOUR{}:RAD:ARB:FREQ:OFFS {}".format(sg, offset) 685 self.send_command(cmd) 686 687 def get_arb_freq_offset_aorb(self, sg=1): 688 """ Gets the frequency offset of Pattern A/Pattern B based on Baseband 689 center frequency 690 691 Args: 692 sg: signal generator number. 693 Default is 1 694 695 Returns: 696 frequency offset 697 """ 698 return self.send_query("SOUR{}:RAD:ARB:WM{}:FREQ:OFFS?".format(sg, 699 a_or_b)) 700 701 def set_arb_freq_offset_aorb(self, a_or_b, offset, sg=1): 702 """ Sets the frequency offset of Pattern A/Pattern B based on Baseband 703 center frequency 704 705 Args: 706 sg: signal generator number. 707 Default is 1 708 a_or_b : Patten A or Pattern B( "A" or "B") 709 offset : frequency offset 710 711 Returns: 712 None 713 """ 714 cmd = "SOUR{}:RAD:ARB:WM{}:FREQ:OFFS {}".format(sg, a_or_b, offset) 715 self.send_command(cmd) 716
