| 1 | package Lab::Instrument::HP33120A; | ||
| 2 | #ABSTRACT: HP 33120A 15MHz function/arbitrary waveform generator | ||
| 3 | $Lab::Instrument::HP33120A::VERSION = '3.899'; | ||
| 4 | use v5.20; | ||
| 5 | |||
| 6 | use strict; | ||
| 7 | use warnings; | ||
| 8 | use Lab::Instrument; | ||
| 9 | use Try::Tiny; | ||
| 10 | use Carp; | ||
| 11 | use English; | ||
| 12 | |||
| 13 | our @ISA = ("Lab::Instrument"); | ||
| 14 | |||
| 15 | our %fields = ( | ||
| 16 | supported_connections => ['GPIB'], | ||
| 17 | |||
| 18 | #default settings for connections | ||
| 19 | |||
| 20 | connection_settings => { | ||
| 21 | gpib_board => 0, | ||
| 22 | gpib_address => undef, | ||
| 23 | }, | ||
| 24 | |||
| 25 | device_settings => {}, | ||
| 26 | |||
| 27 | scpi_override => {}, | ||
| 28 | |||
| 29 | device_cache => { | ||
| 30 | id => undef, | ||
| 31 | shape => undef, | ||
| 32 | frequency => undef, | ||
| 33 | amplitude => undef, | ||
| 34 | offset => undef, | ||
| 35 | duty_cycle => undef, | ||
| 36 | load => undef, | ||
| 37 | sync => undef, | ||
| 38 | vunit => undef, | ||
| 39 | |||
| 40 | user_waveform => undef, | ||
| 41 | trigger_source => undef, | ||
| 42 | trigger_slope => undef, | ||
| 43 | display => undef, | ||
| 44 | am_depth => undef, | ||
| 45 | am_shape => undef, | ||
| 46 | am_frequency => undef, | ||
| 47 | am_source => undef, | ||
| 48 | |||
| 49 | fm_deviation => undef, | ||
| 50 | fm_shape => undef, | ||
| 51 | fm_frequency => undef, | ||
| 52 | |||
| 53 | burst_cycles => undef, | ||
| 54 | burst_phase => undef, | ||
| 55 | burst_rate => undef, | ||
| 56 | burst_source => undef, | ||
| 57 | |||
| 58 | fsk_frequency => undef, | ||
| 59 | fsk_rate => undef, | ||
| 60 | fsk_source => undef, | ||
| 61 | |||
| 62 | sweep_start_frequency => undef, | ||
| 63 | sweep_stop_frequency => undef, | ||
| 64 | sweep_spacing => undef, | ||
| 65 | sweep_time => undef, | ||
| 66 | |||
| 67 | modulation => undef, | ||
| 68 | }, | ||
| 69 | |||
| 70 | waveforms => { | ||
| 71 | user => [], | ||
| 72 | }, | ||
| 73 | ); | ||
| 74 | |||
| 75 | |||
| 76 | sub new { | ||
| 77 | my $proto = shift; | ||
| 78 | my $class = ref($proto) || $proto; | ||
| 79 | my $self = $class->SUPER::new(@_); | ||
| 80 | $self->${ \( __PACKAGE__ . '::_construct' ) }(__PACKAGE__); | ||
| 81 | |||
| 82 | return $self; | ||
| 83 | } | ||
| 84 | |||
| 85 | sub _device_init { | ||
| 86 | |||
| 87 | # when NI-GPIB-USB-HS initially plugged in, first write | ||
| 88 | # fails with timeout, so try a 'write nothing significant', let it | ||
| 89 | # fail, after that it should be okay | ||
| 90 | |||
| 91 | my $self = shift; | ||
| 92 | try { | ||
| 93 | $self->write( command => ' ', ); | ||
| 94 | } | ||
| 95 | catch { 1; }; | ||
| 96 | |||
| 97 | } | ||
| 98 | |||
| 99 | |||
| 100 | sub get_id { | ||
| 101 | my $self = shift; | ||
| 102 | return $self->query('*IDN?'); | ||
| 103 | } | ||
| 104 | |||
| 105 | |||
| 106 | sub get_status { | ||
| 107 | my $self = shift; | ||
| 108 | my $stb = $self->query("*STB?"); | ||
| 109 | my $esr = $self->query("*ESR?"); | ||
| 110 | |||
| 111 | my (%status); | ||
| 112 | $status{'DATA'} = ( $stb & 0x10 ) == 0 ? 0 : 1; | ||
| 113 | $status{'ERROR'} = ( $esr & 0x3C ) == 0 ? 0 : 1; | ||
| 114 | $status{'QERR'} = ( $esr & 0x04 ) == 0 ? 0 : 1; | ||
| 115 | $status{'DERR'} = ( $esr & 0x08 ) == 0 ? 0 : 1; | ||
| 116 | $status{'EERR'} = ( $esr & 0x10 ) == 0 ? 0 : 1; | ||
| 117 | $status{'CERR'} = ( $esr & 0x20 ) == 0 ? 0 : 1; | ||
| 118 | $status{'PON'} = ( $esr & 0x80 ) == 0 ? 0 : 1; | ||
| 119 | $status{'OPC'} = ( $esr & 0x01 ) == 0 ? 0 : 1; | ||
| 120 | return %status; | ||
| 121 | } | ||
| 122 | |||
| 123 | |||
| 124 | sub get_error { | ||
| 125 | my $self = shift; | ||
| 126 | my $err = $self->query("SYST:ERR?"); | ||
| 127 | if ( $err =~ /^\s*\+?0+\s*,/ ) { | ||
| 128 | return ( 0, '' ); # no error | ||
| 129 | } | ||
| 130 | |||
| 131 | my ( $code, $msg ) = split( /,/, $err ); | ||
| 132 | return ( $code, $msg ); | ||
| 133 | } | ||
| 134 | |||
| 135 | |||
| 136 | our $rst_cache = { | ||
| 137 | shape => 'SIN', | ||
| 138 | frequency => 1000, | ||
| 139 | amplitude => 0.1, | ||
| 140 | offset => 0, | ||
| 141 | load => 50, | ||
| 142 | sync => 1, | ||
| 143 | vunit => 'VPP', | ||
| 144 | |||
| 145 | trigger_source => 'IMM', | ||
| 146 | display => 1, | ||
| 147 | am_depth => 100, | ||
| 148 | am_shape => 'SIN', | ||
| 149 | am_frequency => 100, | ||
| 150 | am_source => 'INT', | ||
| 151 | |||
| 152 | fm_deviation => 100, | ||
| 153 | fm_shape => 'SIN', | ||
| 154 | fm_frequency => 10, | ||
| 155 | |||
| 156 | burst_cycles => 1, | ||
| 157 | burst_phase => 0, | ||
| 158 | burst_rate => 100, | ||
| 159 | burst_source => 'INT', | ||
| 160 | |||
| 161 | fsk_frequency => 100, | ||
| 162 | fsk_rate => 10, | ||
| 163 | fsk_source => 'INT', | ||
| 164 | |||
| 165 | sweep_start_frequency => 100, | ||
| 166 | sweep_stop_frequency => 1000, | ||
| 167 | sweep_spacing => 'LIN', | ||
| 168 | sweep_time => 1, | ||
| 169 | |||
| 170 | modulation => 'NONE', | ||
| 171 | }; | ||
| 172 | |||
| 173 | sub reset { | ||
| 174 | my $self = shift; | ||
| 175 | |||
| 176 | my $mod = $self->get_modulation( { read_mode => 'cache' } ); | ||
| 177 | |||
| 178 | $self->write('*RST'); | ||
| 179 | $self->write('*CLS'); | ||
| 180 | $self->wait_complete(); | ||
| 181 | |||
| 182 | # set cache to *RST values | ||
| 183 | |||
| 184 | foreach my $k ( keys( %{$rst_cache} ) ) { | ||
| 185 | $self->{device_cache}->{$k} = $rst_cache->{$k}; | ||
| 186 | } | ||
| 187 | |||
| 188 | if ( $mod =~ /^SWE/i ) { | ||
| 189 | $self->{device_cache}->{sweep_start_frequency} = 0.01; | ||
| 190 | $self->{device_cache}->{sweep_stop_frequency} = 15000000; | ||
| 191 | } | ||
| 192 | |||
| 193 | } | ||
| 194 | |||
| 195 | |||
| 196 | sub get_trigger_slope { | ||
| 197 | my $self = shift; | ||
| 198 | return $self->query('TRIG:SLOP?'); | ||
| 199 | } | ||
| 200 | |||
| 201 | |||
| 202 | sub set_trigger_slope { | ||
| 203 | my $self = shift; | ||
| 204 | my $in = shift; | ||
| 205 | my $sl; | ||
| 206 | if ( $in =~ /^\s*[p+]/i ) { | ||
| 207 | $sl = 'POS'; | ||
| 208 | } | ||
| 209 | elsif ( $in =~ /^\s*[n\-]/i ) { | ||
| 210 | $sl = 'NEG'; | ||
| 211 | } | ||
| 212 | else { | ||
| 213 | Lab::Exception::CorruptParameter->throw( | ||
| 214 | "Invalid trigger slope '$in' [POS|NEG]\n"); | ||
| 215 | return; | ||
| 216 | } | ||
| 217 | $self->write("TRIG:SLOP $sl"); | ||
| 218 | } | ||
| 219 | |||
| 220 | |||
| 221 | sub wait_complete { | ||
| 222 | my $self = shift; | ||
| 223 | $self->write('*WAI'); | ||
| 224 | } | ||
| 225 | |||
| 226 | |||
| 227 | sub trigger { | ||
| 228 | my $self = shift; | ||
| 229 | $self->write('*TRG'); | ||
| 230 | $self->wait_complete(); | ||
| 231 | } | ||
| 232 | |||
| 233 | |||
| 234 | sub get_trigger_source { | ||
| 235 | my $self = shift; | ||
| 236 | return $self->query("TRIG:SOUR?"); | ||
| 237 | } | ||
| 238 | |||
| 239 | |||
| 240 | sub set_trigger_source { | ||
| 241 | my $self = shift; | ||
| 242 | my $in = shift; | ||
| 243 | my $s; | ||
| 244 | if ( $in =~ /^\s*IMM/i ) { | ||
| 245 | $s = 'IMM'; | ||
| 246 | } | ||
| 247 | elsif ( $in =~ /^\s*BUS/i ) { | ||
| 248 | $s = 'BUS'; | ||
| 249 | } | ||
| 250 | elsif ( $in =~ /^\s*EXT/i ) { | ||
| 251 | $s = 'EXT'; | ||
| 252 | } | ||
| 253 | else { | ||
| 254 | Lab::Exception::CorruptParameter->throw( | ||
| 255 | "Set_trigger_source invalid input '$in' [IMM|BUS|EXT]\n"); | ||
| 256 | return; | ||
| 257 | } | ||
| 258 | $self->write("TRIG:SOUR $s"); | ||
| 259 | } | ||
| 260 | |||
| 261 | |||
| 262 | sub set_display { | ||
| 263 | my $self = shift; | ||
| 264 | my $in = shift; | ||
| 265 | my $state; | ||
| 266 | if ( $in =~ /^\s*(1|on|t|y)/i ) { | ||
| 267 | $state = 1; | ||
| 268 | } | ||
| 269 | elsif ( $in =~ /^\s*(0|of|f|n)/i ) { | ||
| 270 | $state = 0; | ||
| 271 | } | ||
| 272 | else { | ||
| 273 | Lab::Exception::CorruptParameter->throw( | ||
| 274 | "Invalid display setting '$in' [ON|OFF]\n"); | ||
| 275 | return; | ||
| 276 | } | ||
| 277 | $self->write("DISP $state"); | ||
| 278 | } | ||
| 279 | |||
| 280 | |||
| 281 | sub get_display { | ||
| 282 | my $self = shift; | ||
| 283 | return $self->query("DISP?"); | ||
| 284 | } | ||
| 285 | |||
| 286 | |||
| 287 | sub set_text { | ||
| 288 | my $self = shift; | ||
| 289 | my $in = shift; | ||
| 290 | $in =~ s/\'/''/g; | ||
| 291 | $self->write("DISP:TEXT '$in'"); | ||
| 292 | } | ||
| 293 | |||
| 294 | |||
| 295 | sub get_text { | ||
| 296 | my $self = shift; | ||
| 297 | my $txt = $self->query('DISP:TEXT?'); | ||
| 298 | my (@s) = _parseStrings($txt); | ||
| 299 | return $s[0]; | ||
| 300 | } | ||
| 301 | |||
| 302 | |||
| 303 | sub clear_text { | ||
| 304 | my $self = shift; | ||
| 305 | $self->write("DISP:TEXT:CLE"); | ||
| 306 | } | ||
| 307 | |||
| 308 | |||
| 309 | sub beep { | ||
| 310 | my $self = shift; | ||
| 311 | $self->write("SYST:BEEP"); | ||
| 312 | } | ||
| 313 | |||
| 314 | |||
| 315 | sub get_sync { | ||
| 316 | my $self = shift; | ||
| 317 | return $self->query("OUTP:SYNC?"); | ||
| 318 | } | ||
| 319 | |||
| 320 | |||
| 321 | sub set_sync { | ||
| 322 | my $self = shift; | ||
| 323 | my $in = shift; | ||
| 324 | my $sync; | ||
| 325 | if ( $in =~ /^\s*(1|on|t|y)/i ) { | ||
| 326 | $sync = 1; | ||
| 327 | } | ||
| 328 | elsif ( $in =~ /^\s*(0|of|f|n)/i ) { | ||
| 329 | $sync = 0; | ||
| 330 | } | ||
| 331 | else { | ||
| 332 | Lab::Exception::CorruptParameter->throw( | ||
| 333 | "Sync '$in' not recognized as boolean \n"); | ||
| 334 | return; | ||
| 335 | } | ||
| 336 | $self->write("OUTP:SYNC $sync"); | ||
| 337 | } | ||
| 338 | |||
| 339 | |||
| 340 | sub save_setup { | ||
| 341 | my $self = shift; | ||
| 342 | my $n = shift; | ||
| 343 | $n = int( $n + 0.5 ); | ||
| 344 | if ( $n < 0 || $n > 3 ) { | ||
| 345 | Lab::Exception::CorruptParameter->throw( | ||
| 346 | "Save '$n' out of range (0..3)\n"); | ||
| 347 | return; | ||
| 348 | } | ||
| 349 | $self->write("*SAV $n"); | ||
| 350 | } | ||
| 351 | |||
| 352 | |||
| 353 | sub recall_setup { | ||
| 354 | my $self = shift; | ||
| 355 | my $n = shift; | ||
| 356 | $n = int( $n + 0.5 ); | ||
| 357 | if ( $n < 0 || $n > 3 ) { | ||
| 358 | Lab::Exception::CorruptParameter->throw( | ||
| 359 | "Recall '$n' out of range (0..3)\n"); | ||
| 360 | return; | ||
| 361 | } | ||
| 362 | $self->write("*RCL $n"); | ||
| 363 | |||
| 364 | # invalidate the cache | ||
| 365 | $self->reset_device_cache(); | ||
| 366 | } | ||
| 367 | |||
| 368 | |||
| 369 | sub delete_setup { | ||
| 370 | my $self = shift; | ||
| 371 | my $n = shift; | ||
| 372 | $n = int( $n + 0.5 ); | ||
| 373 | |||
| 374 | if ( $n < 0 || $n > 3 ) { | ||
| 375 | Lab::Exception::CorruptParameter->throw( | ||
| 376 | "Delete '$n' out of range (0..3)\n"); | ||
| 377 | return; | ||
| 378 | } | ||
| 379 | $self->write("MEM:STAT:DEL $n"); | ||
| 380 | } | ||
| 381 | |||
| 382 | |||
| 383 | sub get_load { | ||
| 384 | my $self = shift; | ||
| 385 | my $z = $self->query("OUTP:LOAD?"); | ||
| 386 | $z = 'INF' if $z > 1000; | ||
| 387 | return $z; | ||
| 388 | } | ||
| 389 | |||
| 390 | |||
| 391 | sub set_load { | ||
| 392 | my $self = shift; | ||
| 393 | my $in = shift; | ||
| 394 | my $z; | ||
| 395 | |||
| 396 | if ( $in =~ /^\s*inf/i ) { | ||
| 397 | $z = 'INF'; | ||
| 398 | } | ||
| 399 | else { | ||
| 400 | my $zin = _parseNRf( $in, 'ohm' ); | ||
| 401 | if ( $zin =~ /^ERR/i ) { | ||
| 402 | Lab::Exception::CorruptParameter->throw( | ||
| 403 | "Parse error in load impedance '$in': $zin\n"); | ||
| 404 | return; | ||
| 405 | } | ||
| 406 | |||
| 407 | if ( $zin ne 'MIN' && $zin ne 'MAX' ) { | ||
| 408 | if ( $zin > 40 && $zin < 60 ) { | ||
| 409 | $z = 50; | ||
| 410 | } | ||
| 411 | elsif ( $zin > 50e3 ) { | ||
| 412 | $z = 'INF'; | ||
| 413 | } | ||
| 414 | else { | ||
| 415 | Lab::Exception::CorruptParameter->throw( | ||
| 416 | "Invalid load impedance '$in' [MIN,MAX,INF,50]\n"); | ||
| 417 | return; | ||
| 418 | } | ||
| 419 | } | ||
| 420 | else { | ||
| 421 | $z = $zin; | ||
| 422 | } | ||
| 423 | } | ||
| 424 | $self->write("OUTP:LOAD $z"); | ||
| 425 | } | ||
| 426 | |||
| 427 | |||
| 428 | sub get_shape { | ||
| 429 | my $self = shift; | ||
| 430 | return $self->query('FUNC:SHAP?'); | ||
| 431 | } | ||
| 432 | |||
| 433 | |||
| 434 | sub set_shape { | ||
| 435 | my $self = shift; | ||
| 436 | my $shape = shift; | ||
| 437 | my $s; | ||
| 438 | if ( $shape =~ /^SIN/i ) { | ||
| 439 | $s = 'SIN'; | ||
| 440 | } | ||
| 441 | elsif ( $shape =~ /^SQU/i ) { | ||
| 442 | $s = 'SQU'; | ||
| 443 | } | ||
| 444 | elsif ( $shape =~ /^TRI/i ) { | ||
| 445 | $s = 'TRI'; | ||
| 446 | } | ||
| 447 | elsif ( $shape =~ /^RAMP/i ) { | ||
| 448 | $s = 'RAMP'; | ||
| 449 | } | ||
| 450 | elsif ( $shape =~ /^NOIS/i ) { | ||
| 451 | $s = 'NOIS'; | ||
| 452 | } | ||
| 453 | elsif ( $shape =~ /^DC/i ) { | ||
| 454 | $s = 'DC'; | ||
| 455 | } | ||
| 456 | elsif ( $shape =~ /^USER/i ) { | ||
| 457 | $s = 'USER'; | ||
| 458 | } | ||
| 459 | else { | ||
| 460 | Lab::Exception::CorruptParameter->throw( | ||
| 461 | "Invalid function shape '$shape'\n"); | ||
| 462 | return; | ||
| 463 | } | ||
| 464 | $self->write("FUNC:SHAP $s"); | ||
| 465 | } | ||
| 466 | |||
| 467 | |||
| 468 | sub get_frequency { | ||
| 469 | my $self = shift; | ||
| 470 | return $self->query("FREQ?"); | ||
| 471 | } | ||
| 472 | |||
| 473 | |||
| 474 | sub set_frequency { | ||
| 475 | my $self = shift; | ||
| 476 | my $freq = shift; | ||
| 477 | my $f = _parseNRf( $freq, 'hz' ); | ||
| 478 | |||
| 479 | if ( $f =~ /^ERR/i ) { | ||
| 480 | Lab::Exception::CorruptParameter->throw( | ||
| 481 | "Error parsing frequency '$freq': $f\n"); | ||
| 482 | return; | ||
| 483 | } | ||
| 484 | |||
| 485 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 486 | $f = sprintf( '%.11e', $f ); | ||
| 487 | my $shape = $self->get_shape( { read_mode => 'cache' } ); | ||
| 488 | my $maxf = 15e6; | ||
| 489 | $maxf = 100e3 if $shape eq 'RAMP' || $shape eq 'TRI'; | ||
| 490 | $maxf = 5e6 if $shape eq 'USER'; # fix, points dependent | ||
| 491 | |||
| 492 | if ( $f < 100e-6 || $f > $maxf ) { | ||
| 493 | Lab::Exception::CorruptParameter->throw( | ||
| 494 | "Frequency '$freq' out of valid range 100uHz..${maxf}Hz\n"); | ||
| 495 | return; | ||
| 496 | } | ||
| 497 | } | ||
| 498 | $self->write("FREQ $f"); | ||
| 499 | } | ||
| 500 | |||
| 501 | |||
| 502 | sub get_duty_cycle { | ||
| 503 | my $self = shift; | ||
| 504 | return $self->query('PULS:DCYC?'); | ||
| 505 | } | ||
| 506 | |||
| 507 | |||
| 508 | sub set_duty_cycle { | ||
| 509 | my $self = shift; | ||
| 510 | my $in = shift; | ||
| 511 | my $dc = _parseNRf( $in, '' ); | ||
| 512 | |||
| 513 | if ( $dc =~ /^ERR/i ) { | ||
| 514 | Lab::Exception::CorruptParameter->throw( | ||
| 515 | "Error parsing duty-cycle '$in': $dc\n"); | ||
| 516 | return; | ||
| 517 | } | ||
| 518 | if ( $dc ne 'MIN' && $dc ne 'MAX' ) { | ||
| 519 | my $f = $self->get_frequency( { read_mode => 'cache' } ); | ||
| 520 | |||
| 521 | $dc = int( $dc + 0.5 ); | ||
| 522 | my $dcmin = 20; | ||
| 523 | my $dcmax = 80; | ||
| 524 | if ( $f > 5e6 ) { | ||
| 525 | $dcmin = 40; | ||
| 526 | $dcmax = 60; | ||
| 527 | } | ||
| 528 | if ( $dc < $dcmin || $dc > $dcmax ) { | ||
| 529 | Lab::Exception::CorruptParameter->throw( | ||
| 530 | "Duty-cycle '$in' outside valid range ($dcmin..$dcmax)\n"); | ||
| 531 | return; | ||
| 532 | } | ||
| 533 | } | ||
| 534 | $self->write("PULS:DCYC $dc"); | ||
| 535 | } | ||
| 536 | |||
| 537 | |||
| 538 | sub get_amplitude { | ||
| 539 | my $self = shift; | ||
| 540 | return $self->query("volt?"); | ||
| 541 | } | ||
| 542 | |||
| 543 | |||
| 544 | sub set_amplitude { | ||
| 545 | my $self = shift; | ||
| 546 | my $in = shift; | ||
| 547 | my $v = _parseNRf( $in, 'v', 'db', 'dbv' ); | ||
| 548 | |||
| 549 | if ( $v =~ /^ERR/i ) { | ||
| 550 | Lab::Exception::CorruptParameter->throw( | ||
| 551 | "Error parsing amplitude '$in': $v\n"); | ||
| 552 | return; | ||
| 553 | } | ||
| 554 | if ( $v ne 'MIN' && $v ne 'MAX' ) { | ||
| 555 | $v = sprintf( '%.4e', $v ); | ||
| 556 | my $z = $self->get_load( { read_mode => 'cache' } ); | ||
| 557 | my $u = $self->get_vunit( { read_mode => 'cache' } ); | ||
| 558 | my $s = $self->get_shape( { read_mode => 'cache' } ); | ||
| 559 | my $voff = $self->get_offset( { read_mode => 'cache' } ); | ||
| 560 | |||
| 561 | my $vpp; | ||
| 562 | if ( $u eq 'VPP' ) { | ||
| 563 | $vpp = $v; | ||
| 564 | } | ||
| 565 | elsif ( $u eq 'VRMS' || $u eq 'DBM' ) { | ||
| 566 | my $vrms = $v; | ||
| 567 | $vrms = 0.224 * ( 10**( $v / 20 ) ); | ||
| 568 | if ( $s eq 'SQU' ) { | ||
| 569 | $vpp = 2 * $vrms; | ||
| 570 | } | ||
| 571 | elsif ( $s eq 'DC' ) { | ||
| 572 | $vpp = $vrms; | ||
| 573 | } | ||
| 574 | elsif ( $s eq 'SIN' ) { | ||
| 575 | $vpp = 2 * sqrt(2) * $vrms; | ||
| 576 | } | ||
| 577 | elsif ( $s eq 'TRI' || $s eq 'RAMP' ) { | ||
| 578 | $vpp = 2 * sqrt(3) * $vrms; | ||
| 579 | } | ||
| 580 | elsif ( $s eq 'NOIS' ) { | ||
| 581 | $vpp = 6.6 * $vrms; # a guess, 99.9% of the time | ||
| 582 | } | ||
| 583 | elsif ( $s eq 'USER' ) { | ||
| 584 | $vpp = 2 * sqrt(2) * $vrms; # a guess, fix later | ||
| 585 | } | ||
| 586 | } | ||
| 587 | |||
| 588 | my $vmin = 100e-3; | ||
| 589 | my $vmax = 20; | ||
| 590 | $vmin = 50e-3 if $z == 50; | ||
| 591 | $vmax = 10 if $z == 50; | ||
| 592 | |||
| 593 | if ( $vpp < $vmin || $vpp > $vmax ) { | ||
| 594 | Lab::Exception::CorruptParameter->throw( | ||
| 595 | "Amplitude '$in' out of range ($vmin..$vmax)\n"); | ||
| 596 | return; | ||
| 597 | } | ||
| 598 | |||
| 599 | if ( abs($voff) > 2 * $vpp ) { | ||
| 600 | Lab::Exception::CorruptParameter->throw( | ||
| 601 | "Amplitude '$in' gives |Voff| > 2Vpp\n"); | ||
| 602 | return; | ||
| 603 | } | ||
| 604 | if ( abs($voff) + 0.5 * $vpp > $vmax ) { | ||
| 605 | Lab::Exception::CorruptParameter->throw( | ||
| 606 | "Amplitude '$in' gives |Voff|+Vpp/2 > Vmax\n"); | ||
| 607 | return; | ||
| 608 | } | ||
| 609 | |||
| 610 | } | ||
| 611 | $self->write("VOLT $v"); | ||
| 612 | } | ||
| 613 | |||
| 614 | |||
| 615 | sub get_vunit { | ||
| 616 | my $self = shift; | ||
| 617 | return $self->query("VOLT:UNIT?"); | ||
| 618 | } | ||
| 619 | |||
| 620 | |||
| 621 | sub set_vunit { | ||
| 622 | my $self = shift; | ||
| 623 | my $in = shift; | ||
| 624 | $in =~ s/^\s+//; | ||
| 625 | $in =~ s/\s+$//; | ||
| 626 | my $u; | ||
| 627 | if ( $in =~ /pp/i ) { | ||
| 628 | $u = 'VPP'; | ||
| 629 | } | ||
| 630 | elsif ( $in =~ /rms/i ) { | ||
| 631 | $u = 'VRMS'; | ||
| 632 | } | ||
| 633 | elsif ( $in =~ /dbm/i ) { | ||
| 634 | $u = 'DBM'; | ||
| 635 | } | ||
| 636 | elsif ( $in =~ /def/i ) { | ||
| 637 | $u = 'DEF'; | ||
| 638 | } | ||
| 639 | else { | ||
| 640 | Lab::Exception::CorruptParameter->throw( | ||
| 641 | "Invalid vunit '$in' [VPP,VRMS,DBM,DEFAULT]\n"); | ||
| 642 | return; | ||
| 643 | } | ||
| 644 | $self->write("VOLT:UNIT $u"); | ||
| 645 | } | ||
| 646 | |||
| 647 | |||
| 648 | sub get_offset { | ||
| 649 | my $self = shift; | ||
| 650 | return $self->query("VOLT:OFFS?"); | ||
| 651 | } | ||
| 652 | |||
| 653 | |||
| 654 | sub set_offset { | ||
| 655 | my $self = shift; | ||
| 656 | my $in = shift; | ||
| 657 | |||
| 658 | my $voff = _parseNRf( $in, 'v' ); | ||
| 659 | if ( $voff =~ /^ERR/ ) { | ||
| 660 | Lab::Exception::CorruptParameter->throw( | ||
| 661 | "Error parsing '$in': $voff\n"); | ||
| 662 | return; | ||
| 663 | } | ||
| 664 | if ( $voff ne 'MIN' && $voff ne 'MAX' ) { | ||
| 665 | $voff = sprintf( '%.4e', $voff ); | ||
| 666 | my $u = $self->get_vunit( { read_mode => 'cache' } ); | ||
| 667 | my $vpp; | ||
| 668 | if ( $u ne 'VPP' ) { | ||
| 669 | $self->set_vunit('VPP'); | ||
| 670 | $vpp = $self->get_amplitude( { read_mode => 'device' } ); | ||
| 671 | $self->set_vunit($u); | ||
| 672 | $self->get_amplitude( { read_mode => 'device' } ); # reset cache | ||
| 673 | } | ||
| 674 | else { | ||
| 675 | $vpp = $self->get_amplitude( { read_mode => 'cache' } ); | ||
| 676 | } | ||
| 677 | my $z = $self->get_load( { read_mode => 'cache' } ); | ||
| 678 | my $vmax = 20; | ||
| 679 | $vmax = 10 if $z == 50; | ||
| 680 | if ( abs($voff) > 2 * $vpp ) { | ||
| 681 | Lab::Exception::CorruptParameter->throw( | ||
| 682 | "|Voffset| > 2*Vpp: $voff\n"); | ||
| 683 | return; | ||
| 684 | } | ||
| 685 | if ( abs($voff) + 0.5 * $vpp > $vmax ) { | ||
| 686 | Lab::Exception::CorruptParameter->throw( | ||
| 687 | "|Voffset|+Vpp/2 > $vmax: Voffset = $voff\n"); | ||
| 688 | return; | ||
| 689 | } | ||
| 690 | } | ||
| 691 | $self->write("VOLT:OFFS $voff"); | ||
| 692 | } | ||
| 693 | |||
| 694 | # use a "special" cache for this, because we need to store | ||
| 695 | # an array of names | ||
| 696 | |||
| 697 | |||
| 698 | sub get_waveform_list { | ||
| 699 | my $self = shift; | ||
| 700 | |||
| 701 | my ($read_mode) = $self->_check_args( \@_, ['read_mode'] ); | ||
| 702 | $read_mode = 'device' unless defined($read_mode); | ||
| 703 | |||
| 704 | if ( $read_mode eq 'cache' | ||
| 705 | && $#{ $self->{waveform}->{user} } >= 0 | ||
| 706 | && !$self->{config}->{no_cache} ) { | ||
| 707 | return ( @{ $self->{waveform}->{user} } ); | ||
| 708 | } | ||
| 709 | |||
| 710 | my $wfs = $self->query("DATA:CAT?"); | ||
| 711 | $self->{waveform}->{user} = [ _parseStrings($wfs) ]; | ||
| 712 | return ( @{ $self->{waveform}->{user} } ); | ||
| 713 | } | ||
| 714 | |||
| 715 | |||
| 716 | sub get_user_waveform { | ||
| 717 | my $self = shift; | ||
| 718 | return $self->query("FUNC:USER?"); | ||
| 719 | } | ||
| 720 | |||
| 721 | |||
| 722 | sub set_user_waveform { | ||
| 723 | my $self = shift; | ||
| 724 | my $in = shift; | ||
| 725 | $in =~ s/^\s+//; | ||
| 726 | $in =~ s/\s+$//; | ||
| 727 | |||
| 728 | if ( $in !~ /^[a-z]\w+$/i || length($in) > 8 ) { | ||
| 729 | Lab::Exception::CorruptParameter->throw( | ||
| 730 | "Invalid arbitrary waveform name '$in' (a-z,0-9,_; len < 9) \n"); | ||
| 731 | return; | ||
| 732 | } | ||
| 733 | $in = uc($in); | ||
| 734 | |||
| 735 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 736 | |||
| 737 | my $got = 0; | ||
| 738 | foreach my $wf ( @w, 'VOLATILE' ) { | ||
| 739 | $got++ if $wf eq $in; | ||
| 740 | } | ||
| 741 | if ( $got == 0 ) { | ||
| 742 | Lab::Exception::CorruptParameter->throw( | ||
| 743 | "Unknown USER waveform '$in' for set_user_waveform\n"); | ||
| 744 | return; | ||
| 745 | } | ||
| 746 | $self->write("FUNC:USER $in"); | ||
| 747 | } | ||
| 748 | |||
| 749 | |||
| 750 | sub load_waveform { | ||
| 751 | my $self = shift; | ||
| 752 | my $arg = shift; | ||
| 753 | my $fwfd; | ||
| 754 | my $dac; | ||
| 755 | |||
| 756 | if ( ref($arg) eq 'HASH' ) { | ||
| 757 | if ( exists( $arg->{waveform} ) | ||
| 758 | && ref( $arg->{waveform} ) eq 'ARRAY' ) { | ||
| 759 | $fwfd = $arg->{waveform}; | ||
| 760 | } | ||
| 761 | elsif ( exists( $arg->{dac} ) && ref( $arg->{dac} ) eq 'ARRAY' ) { | ||
| 762 | $dac = $arg->{dac}; | ||
| 763 | } | ||
| 764 | } | ||
| 765 | else { | ||
| 766 | if ( ref($arg) eq 'ARRAY' ) { | ||
| 767 | $fwfd = $arg; | ||
| 768 | } | ||
| 769 | elsif ( ref($arg) eq '' ) { | ||
| 770 | $fwfd = [ $arg, @_ ]; | ||
| 771 | } | ||
| 772 | |||
| 773 | if ( defined($fwfd) ) { | ||
| 774 | my ( $minv, $maxv ); | ||
| 775 | foreach my $v ( @{$fwfd} ) { | ||
| 776 | $minv = $v unless defined($minv) && $minv < $v; | ||
| 777 | $maxv = $v unless defined($maxv) && $maxv > $v; | ||
| 778 | } | ||
| 779 | if ( $minv < -1 && $maxv > 1 ) { | ||
| 780 | $dac = $fwfd; | ||
| 781 | $fwfd = undef; | ||
| 782 | } | ||
| 783 | } | ||
| 784 | } | ||
| 785 | |||
| 786 | if ( !defined($fwfd) && !defined($dac) ) { | ||
| 787 | Lab::Exception::CorruptParameter->throw("No waveform data\n"); | ||
| 788 | return; | ||
| 789 | } | ||
| 790 | |||
| 791 | my $npts; | ||
| 792 | my $cmd; | ||
| 793 | if ( defined($dac) ) { | ||
| 794 | $cmd = 'DATA:DAC VOLATILE'; # maybe use gpib data block? | ||
| 795 | $npts = $#{$dac} + 1; | ||
| 796 | for ( my $j = 0; $j < $npts; $j++ ) { | ||
| 797 | my $d = int( $dac->[$j] + 0.5 ); | ||
| 798 | if ( abs($d) > 2047 ) { | ||
| 799 | Lab::Exception::CorruptParameter->throw( | ||
| 800 | "Waveform DAC data point $j ($) out of range -2047..2047 \n" | ||
| 801 | ); | ||
| 802 | return; | ||
| 803 | } | ||
| 804 | $cmd .= ',' . $d; | ||
| 805 | } | ||
| 806 | |||
| 807 | } | ||
| 808 | |||
| 809 | if ( defined($fwfd) ) { | ||
| 810 | $cmd = 'DATA VOLATILE'; | ||
| 811 | $npts = $#{$fwfd} + 1; | ||
| 812 | for ( my $j = 0; $j < $npts; $j++ ) { | ||
| 813 | my $v = sprintf( '%.3f', $fwfd->[$j] ); | ||
| 814 | if ( abs($v) > 1 ) { | ||
| 815 | Lab::Exception::CorruptParameter->throw( | ||
| 816 | "Waveform data point $j ($v) out of range -1..1 \n"); | ||
| 817 | return; | ||
| 818 | } | ||
| 819 | $cmd .= "," . $v; | ||
| 820 | } | ||
| 821 | } | ||
| 822 | |||
| 823 | if ( $npts < 8 || $npts > 16000 ) { | ||
| 824 | Lab::Exception::CorruptParameter->throw( | ||
| 825 | "Number of Waveform data points $npts out of range 8..16000 \n"); | ||
| 826 | return; | ||
| 827 | } | ||
| 828 | $self->write($cmd); | ||
| 829 | } | ||
| 830 | |||
| 831 | |||
| 832 | sub get_waveform_average { | ||
| 833 | my $self = shift; | ||
| 834 | my $name = shift; | ||
| 835 | if ( !defined($name) ) { | ||
| 836 | return $self->query("DATA:ATTR:AVER?"); | ||
| 837 | } | ||
| 838 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 839 | |||
| 840 | my $got = 0; | ||
| 841 | $name = uc($name); | ||
| 842 | foreach my $s (@w) { | ||
| 843 | $got++ if uc($s) eq $name; | ||
| 844 | last if $got; | ||
| 845 | } | ||
| 846 | if ( !$got ) { | ||
| 847 | Lab::Exception::CorruptParameter->throw( | ||
| 848 | "No such stored waveform '$name' \n"); | ||
| 849 | return; | ||
| 850 | } | ||
| 851 | return $self->query("DATA:ATTR:AVER? $name"); | ||
| 852 | } | ||
| 853 | |||
| 854 | |||
| 855 | sub get_waveform_crestfactor { | ||
| 856 | my $self = shift; | ||
| 857 | my $name = shift; | ||
| 858 | if ( !defined($name) ) { | ||
| 859 | return $self->query("DATA:ATTR:CFAC?"); | ||
| 860 | } | ||
| 861 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 862 | |||
| 863 | my $got = 0; | ||
| 864 | $name = uc($name); | ||
| 865 | foreach my $s (@w) { | ||
| 866 | $got++ if uc($s) eq $name; | ||
| 867 | last if $got; | ||
| 868 | } | ||
| 869 | if ( !$got ) { | ||
| 870 | Lab::Exception::CorruptParameter->throw( | ||
| 871 | "No such stored waveform '$name' \n"); | ||
| 872 | return; | ||
| 873 | } | ||
| 874 | return $self->query("DATA:ATTR:CFAC? $name"); | ||
| 875 | } | ||
| 876 | |||
| 877 | |||
| 878 | sub get_waveform_points { | ||
| 879 | my $self = shift; | ||
| 880 | my $name = shift; | ||
| 881 | if ( !defined($name) ) { | ||
| 882 | return $self->query("DATA:ATTR:POIN?"); | ||
| 883 | } | ||
| 884 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 885 | |||
| 886 | my $got = 0; | ||
| 887 | $name = uc($name); | ||
| 888 | foreach my $s (@w) { | ||
| 889 | $got++ if uc($s) eq $name; | ||
| 890 | last if $got; | ||
| 891 | } | ||
| 892 | if ( !$got ) { | ||
| 893 | Lab::Exception::CorruptParameter->throw( | ||
| 894 | "No such stored waveform '$name' \n"); | ||
| 895 | return; | ||
| 896 | } | ||
| 897 | return $self->query("DATA:ATTR:POIN? $name"); | ||
| 898 | } | ||
| 899 | |||
| 900 | |||
| 901 | sub get_waveform_peak2peak { | ||
| 902 | my $self = shift; | ||
| 903 | my $name = shift; | ||
| 904 | if ( !defined($name) ) { | ||
| 905 | return $self->query("DATA:ATTR:PTP?"); | ||
| 906 | } | ||
| 907 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 908 | |||
| 909 | my $got = 0; | ||
| 910 | $name = uc($name); | ||
| 911 | foreach my $s (@w) { | ||
| 912 | $got++ if uc($s) eq $name; | ||
| 913 | last if $got; | ||
| 914 | } | ||
| 915 | if ( !$got ) { | ||
| 916 | Lab::Exception::CorruptParameter->throw( | ||
| 917 | "No such stored waveform '$name' \n"); | ||
| 918 | return; | ||
| 919 | } | ||
| 920 | return $self->query("DATA:ATTR:PTP? $name"); | ||
| 921 | } | ||
| 922 | |||
| 923 | |||
| 924 | sub store_waveform { | ||
| 925 | my $self = shift; | ||
| 926 | my $name = shift; | ||
| 927 | $name =~ s/^\s+//; | ||
| 928 | $name =~ s/\s+$//; | ||
| 929 | if ( $name !~ /^[a-z]\w+$/i ) { | ||
| 930 | Lab::Exception::CorruptParameter->throw( | ||
| 931 | "Invalid waveform name '$name' [a-z][a-z,0-9,_]+\n"); | ||
| 932 | return; | ||
| 933 | } | ||
| 934 | if ( length($name) > 8 ) { | ||
| 935 | Lab::Exception::CorruptParameter->throw( | ||
| 936 | "Invalid waveform name '$name' length > 8\n"); | ||
| 937 | return; | ||
| 938 | } | ||
| 939 | $name = uc($name); | ||
| 940 | if ( $name eq 'SINC' | ||
| 941 | || $name eq 'NEG_RAMP' | ||
| 942 | || $name eq 'EXP_RISE' | ||
| 943 | || $name eq 'EXP_FALL' | ||
| 944 | || $name eq 'CARDIAC' | ||
| 945 | || $name eq 'VOLATILE' ) { | ||
| 946 | Lab::Exception::CorruptParameter->throw( | ||
| 947 | "Invalid waveform name '$name' for copy\n"); | ||
| 948 | return; | ||
| 949 | } | ||
| 950 | |||
| 951 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 952 | my $got = 0; | ||
| 953 | foreach my $s (@w) { | ||
| 954 | $got++ if uc($s) eq $name; | ||
| 955 | last if $got; | ||
| 956 | } | ||
| 957 | if ( !$got && $#w == 9 ) { | ||
| 958 | Lab::Exception::CorruptParameter->throw( | ||
| 959 | "Waveform storage is full, delete something \n"); | ||
| 960 | return; | ||
| 961 | } | ||
| 962 | $self->write("DATA:COPY $name"); | ||
| 963 | } | ||
| 964 | |||
| 965 | |||
| 966 | sub delete_waveform { | ||
| 967 | my $self = shift; | ||
| 968 | my $name = shift; | ||
| 969 | $name =~ s/^\s+//; | ||
| 970 | $name =~ s/\s+$//; | ||
| 971 | if ( $name !~ /^[a-z]\w+$/i ) { | ||
| 972 | Lab::Exception::CorruptParameter->throw( | ||
| 973 | "Invalid waveform name '$name' [a-z][a-z,0-9,_]+\n"); | ||
| 974 | return; | ||
| 975 | } | ||
| 976 | if ( length($name) > 8 ) { | ||
| 977 | Lab::Exception::CorruptParameter->throw( | ||
| 978 | "Invalid waveform name '$name' length > 8\n"); | ||
| 979 | return; | ||
| 980 | } | ||
| 981 | $name = uc($name); | ||
| 982 | if ( $name eq 'SINC' | ||
| 983 | || $name eq 'NEG_RAMP' | ||
| 984 | || $name eq 'EXP_RISE' | ||
| 985 | || $name eq 'EXP_FALL' | ||
| 986 | || $name eq 'CARDIAC' ) { | ||
| 987 | Lab::Exception::CorruptParameter->throw( | ||
| 988 | "Built-in waveform '$name' , not deletable\n"); | ||
| 989 | return; | ||
| 990 | } | ||
| 991 | |||
| 992 | my (@w) = $self->get_waveform_list( { read_mode => 'cache' } ); | ||
| 993 | my $got = 0; | ||
| 994 | foreach my $s ( @w, 'VOLATILE' ) { | ||
| 995 | $got++ if uc($s) eq $name; | ||
| 996 | last if $got; | ||
| 997 | } | ||
| 998 | if ( !$got ) { | ||
| 999 | Lab::Exception::CorruptParameter->throw("No such waveform '$name'\n"); | ||
| 1000 | return; | ||
| 1001 | } | ||
| 1002 | $self->write("DATA:DEL $name"); | ||
| 1003 | } | ||
| 1004 | |||
| 1005 | |||
| 1006 | sub get_waveform_free { | ||
| 1007 | my $self = shift; | ||
| 1008 | return $self->query('DATA:NVOL:FREE?'); | ||
| 1009 | } | ||
| 1010 | |||
| 1011 | |||
| 1012 | sub get_modulation { | ||
| 1013 | my $self = shift; | ||
| 1014 | my $mod = 'NONE'; | ||
| 1015 | |||
| 1016 | $mod = 'AM' if $self->query("AM:STAT?"); | ||
| 1017 | $mod = 'FM' if $self->query("FM:STAT?"); | ||
| 1018 | $mod = 'BURST' if $self->query("BM:STAT?"); | ||
| 1019 | $mod = 'FSK' if $self->query("FSK:STAT?"); | ||
| 1020 | $mod = 'SWEEP' if $self->query("SWE:STAT?"); | ||
| 1021 | |||
| 1022 | return $mod; | ||
| 1023 | } | ||
| 1024 | |||
| 1025 | |||
| 1026 | sub set_modulation { | ||
| 1027 | my $self = shift; | ||
| 1028 | my $in = shift; | ||
| 1029 | $in = 'NONE' unless defined($in); | ||
| 1030 | $in = 'NONE' if $in eq ''; | ||
| 1031 | $in =~ s/^\s+//; | ||
| 1032 | my $m; | ||
| 1033 | |||
| 1034 | if ( $in =~ /^NO/i || $in =~ /^OF/i ) { | ||
| 1035 | $m = 'NONE'; | ||
| 1036 | } | ||
| 1037 | elsif ( $in =~ /^AM/i ) { | ||
| 1038 | $m = 'AM'; | ||
| 1039 | } | ||
| 1040 | elsif ( $in =~ /^FM/i ) { | ||
| 1041 | $m = 'FM'; | ||
| 1042 | } | ||
| 1043 | elsif ( $in =~ /^BUR/i ) { | ||
| 1044 | $m = 'BM'; | ||
| 1045 | } | ||
| 1046 | elsif ( $in =~ /^FSK/i ) { | ||
| 1047 | $m = 'FSK'; | ||
| 1048 | } | ||
| 1049 | elsif ( $in =~ /^SWE/i ) { | ||
| 1050 | $m = 'SWE'; | ||
| 1051 | } | ||
| 1052 | else { | ||
| 1053 | Lab::Exception::CorruptParameter->throw( | ||
| 1054 | "Invalid modulation type '$in', should be NONE|AM|FM|BURST|FSK|SWEEP\n" | ||
| 1055 | ); | ||
| 1056 | return; | ||
| 1057 | } | ||
| 1058 | |||
| 1059 | my $cm = $self->get_modulation( { read_mode => 'cache' } ); | ||
| 1060 | $cm = 'BM' if $cm eq 'BURST'; | ||
| 1061 | $cm = 'SWE' if $cm eq 'SWEEP'; | ||
| 1062 | if ( $m eq 'NONE' ) { | ||
| 1063 | $self->write("$cm:STAT 0"); | ||
| 1064 | } | ||
| 1065 | else { | ||
| 1066 | if ( $cm ne 'NONE' ) { | ||
| 1067 | $self->write("$cm:STAT 0"); | ||
| 1068 | } | ||
| 1069 | $self->write("$m:STAT 1"); | ||
| 1070 | } | ||
| 1071 | } | ||
| 1072 | |||
| 1073 | |||
| 1074 | sub set_am_depth { | ||
| 1075 | my $self = shift; | ||
| 1076 | my $in = shift; | ||
| 1077 | my $d = _parseNRf($in); | ||
| 1078 | if ( $d =~ /^ERR:/ ) { | ||
| 1079 | Lab::Exception::CorruptParameter->throw( | ||
| 1080 | "Invalid AM modulation depth '$in' $d\n"); | ||
| 1081 | return; | ||
| 1082 | } | ||
| 1083 | if ( $d ne 'MIN' && $d ne 'MAX' ) { | ||
| 1084 | $d = sprintf( '%.1f', $d ); | ||
| 1085 | if ( $d < 0 || $d > 120 ) { | ||
| 1086 | Lab::Exception::CorruptParameter->throw( | ||
| 1087 | "Invalid AM modulation depth '$in' [0..120|MIN|MAX]\n"); | ||
| 1088 | return; | ||
| 1089 | } | ||
| 1090 | } | ||
| 1091 | $self->write("AM:DEPT $d"); | ||
| 1092 | } | ||
| 1093 | |||
| 1094 | |||
| 1095 | sub get_am_depth { | ||
| 1096 | my $self = shift; | ||
| 1097 | return $self->query("AM:DEPT?"); | ||
| 1098 | } | ||
| 1099 | |||
| 1100 | |||
| 1101 | sub get_am_shape { | ||
| 1102 | my $self = shift; | ||
| 1103 | return $self->query("AM:INT:FUNC?"); | ||
| 1104 | } | ||
| 1105 | |||
| 1106 | |||
| 1107 | sub set_am_shape { | ||
| 1108 | my $self = shift; | ||
| 1109 | my $in = shift; | ||
| 1110 | $in =~ s/^\s+//; | ||
| 1111 | my $s; | ||
| 1112 | |||
| 1113 | if ( $in =~ /^sin/i ) { | ||
| 1114 | $s = 'SIN'; | ||
| 1115 | } | ||
| 1116 | elsif ( $in =~ /^squ/i ) { | ||
| 1117 | $s = 'SQU'; | ||
| 1118 | } | ||
| 1119 | elsif ( $in =~ /^tri/i ) { | ||
| 1120 | $s = 'TRI'; | ||
| 1121 | } | ||
| 1122 | elsif ( $in =~ /^ram/i ) { | ||
| 1123 | $s = 'RAMP'; | ||
| 1124 | } | ||
| 1125 | elsif ( $in =~ /^noi/i ) { | ||
| 1126 | $s = 'NOIS'; | ||
| 1127 | } | ||
| 1128 | elsif ( $in =~ /^use/i ) { | ||
| 1129 | $s = 'USER'; | ||
| 1130 | } | ||
| 1131 | else { | ||
| 1132 | Lab::Exception::CorruptParameter->throw( | ||
| 1133 | "Invalid AM modulation shape '$in' [SIN|SQU|TRI|RAMP|NOIS|USER]\n" | ||
| 1134 | ); | ||
| 1135 | return; | ||
| 1136 | } | ||
| 1137 | $self->write("AM:INT:FUNC $s"); | ||
| 1138 | } | ||
| 1139 | |||
| 1140 | |||
| 1141 | sub get_am_frequency { | ||
| 1142 | my $self = shift; | ||
| 1143 | return $self->query("AM:INT:FREQ?"); | ||
| 1144 | } | ||
| 1145 | |||
| 1146 | |||
| 1147 | sub set_am_frequency { | ||
| 1148 | my $self = shift; | ||
| 1149 | my $in = shift; | ||
| 1150 | |||
| 1151 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1152 | |||
| 1153 | if ( $f =~ /^ERR:/ ) { | ||
| 1154 | Lab::Exception::CorruptParameter->throw( | ||
| 1155 | "Invalid AM modulation frequency '$in' $f\n"); | ||
| 1156 | return; | ||
| 1157 | } | ||
| 1158 | |||
| 1159 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1160 | if ( $f < 10e-3 || $f > 20e3 ) { | ||
| 1161 | Lab::Exception::CorruptParameter->throw( | ||
| 1162 | "AM modulation frequency '$in' out of range 10mHz..20kHz\n"); | ||
| 1163 | return; | ||
| 1164 | } | ||
| 1165 | } | ||
| 1166 | $self->write("AM:INT:FREQ $f"); | ||
| 1167 | } | ||
| 1168 | |||
| 1169 | |||
| 1170 | sub get_am_source { | ||
| 1171 | my $self = shift; | ||
| 1172 | return $self->query("AM:SOUR?"); | ||
| 1173 | } | ||
| 1174 | |||
| 1175 | |||
| 1176 | sub set_am_source { | ||
| 1177 | my $self = shift; | ||
| 1178 | my $in = shift; | ||
| 1179 | my $s; | ||
| 1180 | |||
| 1181 | if ( $in =~ /^\s*BOTH/i ) { | ||
| 1182 | $s = 'BOTH'; | ||
| 1183 | } | ||
| 1184 | elsif ( $in =~ /^\s*INT/i ) { | ||
| 1185 | $s = 'BOTH'; | ||
| 1186 | } | ||
| 1187 | elsif ( $in =~ /^\s*EXT/i ) { | ||
| 1188 | $s = 'EXT'; | ||
| 1189 | } | ||
| 1190 | else { | ||
| 1191 | Lab::Exception::CorruptParameter->throw( | ||
| 1192 | "Invalid AM modulation source '$in' [BOTH|EXT]\n"); | ||
| 1193 | return; | ||
| 1194 | } | ||
| 1195 | $self->write("AM:SOUR $s"); | ||
| 1196 | } | ||
| 1197 | |||
| 1198 | |||
| 1199 | sub get_fm_deviation { | ||
| 1200 | my $self = shift; | ||
| 1201 | return $self->query("FM:DEV?"); | ||
| 1202 | } | ||
| 1203 | |||
| 1204 | |||
| 1205 | sub set_fm_deviation { | ||
| 1206 | my $self = shift; | ||
| 1207 | my $in = shift; | ||
| 1208 | my $d = _parseNRf( $in, 'hz' ); | ||
| 1209 | |||
| 1210 | if ( $d ne 'MIN' && $d ne 'MAX' ) { | ||
| 1211 | my $s = $self->get_shape( { read_mode => 'cache' } ); | ||
| 1212 | my $f = $self->get_frequency( { read_mode => 'cache' } ); | ||
| 1213 | my $fmax = 15.1e6; | ||
| 1214 | $fmax = 200e3 if $s eq 'TRI' || $s eq 'RAMP'; | ||
| 1215 | $fmax = 5.1e6 if $s eq 'USER'; | ||
| 1216 | |||
| 1217 | if ( $d < 10e-3 || $d > $f || $d + $f > $fmax ) { | ||
| 1218 | Lab::Exception::CorruptParameter->throw( | ||
| 1219 | "FM modulation '$in' out of range\n"); | ||
| 1220 | return; | ||
| 1221 | } | ||
| 1222 | } | ||
| 1223 | $self->write("FM:DEV $d"); | ||
| 1224 | } | ||
| 1225 | |||
| 1226 | |||
| 1227 | sub get_fm_shape { | ||
| 1228 | my $self = shift; | ||
| 1229 | return $self->query("FM:INT:FUNC?"); | ||
| 1230 | } | ||
| 1231 | |||
| 1232 | |||
| 1233 | sub set_fm_shape { | ||
| 1234 | my $self = shift; | ||
| 1235 | my $in = shift; | ||
| 1236 | $in =~ s/^\s+//; | ||
| 1237 | my $s; | ||
| 1238 | |||
| 1239 | if ( $in =~ /^sin/i ) { | ||
| 1240 | $s = 'SIN'; | ||
| 1241 | } | ||
| 1242 | elsif ( $in =~ /^squ/i ) { | ||
| 1243 | $s = 'SQU'; | ||
| 1244 | } | ||
| 1245 | elsif ( $in =~ /^tri/i ) { | ||
| 1246 | $s = 'TRI'; | ||
| 1247 | } | ||
| 1248 | elsif ( $in =~ /^ram/i ) { | ||
| 1249 | $s = 'RAMP'; | ||
| 1250 | } | ||
| 1251 | elsif ( $in =~ /^noi/i ) { | ||
| 1252 | $s = 'NOIS'; | ||
| 1253 | } | ||
| 1254 | elsif ( $in =~ /^use/i ) { | ||
| 1255 | $s = 'USER'; | ||
| 1256 | } | ||
| 1257 | else { | ||
| 1258 | Lab::Exception::CorruptParameter->throw( | ||
| 1259 | "Invalid FM modulation shape '$in' [SIN|SQU|TRI|RAMP|NOIS|USER]\n" | ||
| 1260 | ); | ||
| 1261 | return; | ||
| 1262 | } | ||
| 1263 | $self->write("FM:INT:FUNC $s"); | ||
| 1264 | } | ||
| 1265 | |||
| 1266 | |||
| 1267 | sub get_fm_frequency { | ||
| 1268 | my $self = shift; | ||
| 1269 | return $self->query("FM:INT:FREQ?"); | ||
| 1270 | } | ||
| 1271 | |||
| 1272 | |||
| 1273 | sub set_fm_frequency { | ||
| 1274 | my $self = shift; | ||
| 1275 | my $in = shift; | ||
| 1276 | |||
| 1277 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1278 | |||
| 1279 | if ( $f =~ /^ERR:/ ) { | ||
| 1280 | Lab::Exception::CorruptParameter->throw( | ||
| 1281 | "Invalid FM modulation frequency '$in' $f\n"); | ||
| 1282 | return; | ||
| 1283 | } | ||
| 1284 | |||
| 1285 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1286 | if ( $f < 10e-3 || $f > 10e3 ) { | ||
| 1287 | Lab::Exception::CorruptParameter->throw( | ||
| 1288 | "FM modulation frequency '$in' out of range 10mHz..10kHz\n"); | ||
| 1289 | return; | ||
| 1290 | } | ||
| 1291 | } | ||
| 1292 | $self->write("FM:INT:FREQ $f"); | ||
| 1293 | } | ||
| 1294 | |||
| 1295 | |||
| 1296 | sub get_burst_cycles { | ||
| 1297 | my $self = shift; | ||
| 1298 | return $self->query("BM:NCYC?"); | ||
| 1299 | } | ||
| 1300 | |||
| 1301 | |||
| 1302 | sub set_burst_cycles { | ||
| 1303 | my $self = shift; | ||
| 1304 | my $in = shift; | ||
| 1305 | my $ncyc; | ||
| 1306 | if ( $in =~ /^\s*min/i ) { | ||
| 1307 | $ncyc = 'MIN'; | ||
| 1308 | } | ||
| 1309 | elsif ( $in =~ /\s*max/i ) { | ||
| 1310 | $ncyc = 'MAX'; | ||
| 1311 | } | ||
| 1312 | elsif ( $in =~ /\s*inf/i ) { | ||
| 1313 | $ncyc = 'INF'; | ||
| 1314 | } | ||
| 1315 | elsif ( $in =~ /\s*(\d+)/ ) { | ||
| 1316 | $ncyc = $1; | ||
| 1317 | |||
| 1318 | my $f = $self->get_frequency( { read_mode => 'cache' } ); | ||
| 1319 | my $s = $self->get_shape( { read_mode => 'cache' } ); | ||
| 1320 | |||
| 1321 | my $nmax = 50000; | ||
| 1322 | $nmax = int( 500 * $f ) if $f <= 100; | ||
| 1323 | my $nmin = 1; | ||
| 1324 | if ( $s eq 'SIN' || $s eq 'SQU' || $s eq 'USER' ) { | ||
| 1325 | if ( $f <= 1e6 ) { | ||
| 1326 | $nmin = 1; | ||
| 1327 | } | ||
| 1328 | elsif ( $f <= 2e6 ) { | ||
| 1329 | $nmin = 2; | ||
| 1330 | } | ||
| 1331 | elsif ( $f <= 3e6 ) { | ||
| 1332 | $nmin = 3; | ||
| 1333 | } | ||
| 1334 | elsif ( $f <= 4e6 ) { | ||
| 1335 | $nmin = 4; | ||
| 1336 | } | ||
| 1337 | elsif ( $f < 5e6 ) { | ||
| 1338 | $nmin = 5; | ||
| 1339 | } | ||
| 1340 | } | ||
| 1341 | |||
| 1342 | if ( $ncyc < $nmin || $ncyc > $nmax ) { | ||
| 1343 | Lab::Exception::CorruptParameter->throw( | ||
| 1344 | "Burst count '$in' out of range\n"); | ||
| 1345 | return; | ||
| 1346 | } | ||
| 1347 | } | ||
| 1348 | else { | ||
| 1349 | Lab::Exception::CorruptParameter->throw( | ||
| 1350 | "Error parsing burst count '$in'\n"); | ||
| 1351 | return; | ||
| 1352 | } | ||
| 1353 | |||
| 1354 | $self->write("BM:NCYC $ncyc"); | ||
| 1355 | } | ||
| 1356 | |||
| 1357 | |||
| 1358 | sub get_burst_phase { | ||
| 1359 | my $self = shift; | ||
| 1360 | return $self->query("BM:PHAS?"); | ||
| 1361 | } | ||
| 1362 | |||
| 1363 | |||
| 1364 | sub set_burst_phase { | ||
| 1365 | my $self = shift; | ||
| 1366 | my $in = shift; | ||
| 1367 | my $ph = _parseNRf( $in, 'deg' ); | ||
| 1368 | |||
| 1369 | if ( $ph =~ /^ERR:/ ) { | ||
| 1370 | Lab::Exception::CorruptParameter->throw( | ||
| 1371 | "Error parsing burst phase '$in' $ph\n"); | ||
| 1372 | return; | ||
| 1373 | } | ||
| 1374 | |||
| 1375 | if ( $ph ne 'MIN' && $ph ne 'MAX' ) { | ||
| 1376 | $ph = sprintf( "%.3f", $ph ); | ||
| 1377 | if ( $ph < -360 || $ph > 360 ) { | ||
| 1378 | Lab::Exception::CorruptParameter->throw( | ||
| 1379 | "Burst phase '$in' out of range -360..360\n"); | ||
| 1380 | return; | ||
| 1381 | } | ||
| 1382 | } | ||
| 1383 | |||
| 1384 | $self->write("BM:PHAS $ph"); | ||
| 1385 | } | ||
| 1386 | |||
| 1387 | |||
| 1388 | sub get_burst_rate { | ||
| 1389 | my $self = shift; | ||
| 1390 | return $self->query("BM:INT:RATE?"); | ||
| 1391 | } | ||
| 1392 | |||
| 1393 | |||
| 1394 | sub set_burst_rate { | ||
| 1395 | my $self = shift; | ||
| 1396 | my $in = shift; | ||
| 1397 | |||
| 1398 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1399 | |||
| 1400 | if ( $f =~ /^ERR:/ ) { | ||
| 1401 | Lab::Exception::CorruptParameter->throw( | ||
| 1402 | "Burst rate parse '$in' $f\n"); | ||
| 1403 | return; | ||
| 1404 | } | ||
| 1405 | |||
| 1406 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1407 | if ( $f < 10e-3 || $f > 50e3 ) { | ||
| 1408 | Lab::Exception::CorruptParameter->throw( | ||
| 1409 | "Burst rate '$in' out of range 10mHz..50kHz\n"); | ||
| 1410 | return; | ||
| 1411 | } | ||
| 1412 | } | ||
| 1413 | $self->write("BM:INT:RATE $f"); | ||
| 1414 | } | ||
| 1415 | |||
| 1416 | |||
| 1417 | sub get_burst_source { | ||
| 1418 | my $self = shift; | ||
| 1419 | return $self->query("BM:SOUR?"); | ||
| 1420 | } | ||
| 1421 | |||
| 1422 | |||
| 1423 | sub set_burst_source { | ||
| 1424 | my $self = shift; | ||
| 1425 | my $in = shift; | ||
| 1426 | my $s; | ||
| 1427 | if ( $in =~ /^\s*IN/i ) { | ||
| 1428 | $s = 'INT'; | ||
| 1429 | } | ||
| 1430 | elsif ( $in =~ /^\s*EX/i ) { | ||
| 1431 | $s = 'EXT'; | ||
| 1432 | } | ||
| 1433 | else { | ||
| 1434 | Lab::Exception::CorruptParameter->throw( | ||
| 1435 | "Invalid burst source '$in', should be INT or EXT\n"); | ||
| 1436 | return; | ||
| 1437 | } | ||
| 1438 | $self->write("BM:SOUR $s"); | ||
| 1439 | } | ||
| 1440 | |||
| 1441 | |||
| 1442 | sub get_fsk_frequency { | ||
| 1443 | my $self = shift; | ||
| 1444 | return $self->query("FSK:FREQ?"); | ||
| 1445 | } | ||
| 1446 | |||
| 1447 | |||
| 1448 | sub set_fsk_frequency { | ||
| 1449 | my $self = shift; | ||
| 1450 | my $in = shift; | ||
| 1451 | |||
| 1452 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1453 | |||
| 1454 | if ( $f =~ /^ERR:/ ) { | ||
| 1455 | Lab::Exception::CorruptParameter->throw( | ||
| 1456 | "Invalid FSK hop frequency '$in' $f\n"); | ||
| 1457 | return; | ||
| 1458 | } | ||
| 1459 | |||
| 1460 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1461 | my $s = $self->get_shape( { read_mode => 'cache' } ); | ||
| 1462 | my $fmax = 15e6; | ||
| 1463 | $fmax = 100e3 if $s eq 'TRI' || $s eq 'RAMP'; | ||
| 1464 | if ( $f < 10e-3 || $f > $fmax ) { | ||
| 1465 | Lab::Exception::CorruptParameter->throw( | ||
| 1466 | "FSK hop frequency '$in' out of range\n"); | ||
| 1467 | return; | ||
| 1468 | } | ||
| 1469 | } | ||
| 1470 | $self->write("FSK:FREQ $f"); | ||
| 1471 | } | ||
| 1472 | |||
| 1473 | |||
| 1474 | sub get_fsk_rate { | ||
| 1475 | my $self = shift; | ||
| 1476 | return $self->query("FSK:INT:RATE?"); | ||
| 1477 | } | ||
| 1478 | |||
| 1479 | |||
| 1480 | sub set_fsk_rate { | ||
| 1481 | my $self = shift; | ||
| 1482 | my $in = shift; | ||
| 1483 | |||
| 1484 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1485 | |||
| 1486 | if ( $f =~ /^ERR:/ ) { | ||
| 1487 | Lab::Exception::CorruptParameter->throw("FSK rate parse '$in' $f\n"); | ||
| 1488 | return; | ||
| 1489 | } | ||
| 1490 | |||
| 1491 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1492 | if ( $f < 10e-3 || $f > 50e3 ) { | ||
| 1493 | Lab::Exception::CorruptParameter->throw( | ||
| 1494 | "FSK rate '$in' out of range 10mHz..50kHz\n"); | ||
| 1495 | return; | ||
| 1496 | } | ||
| 1497 | } | ||
| 1498 | $self->write("FSK:INT:RATE $f"); | ||
| 1499 | } | ||
| 1500 | |||
| 1501 | |||
| 1502 | sub get_fsk_source { | ||
| 1503 | my $self = shift; | ||
| 1504 | return $self->query("FSK:SOUR?"); | ||
| 1505 | } | ||
| 1506 | |||
| 1507 | |||
| 1508 | sub set_fsk_source { | ||
| 1509 | my $self = shift; | ||
| 1510 | my $in = shift; | ||
| 1511 | my $s; | ||
| 1512 | if ( $in =~ /^\s*IN/i ) { | ||
| 1513 | $s = 'INT'; | ||
| 1514 | } | ||
| 1515 | elsif ( $in =~ /^\s*EX/i ) { | ||
| 1516 | $s = 'EXT'; | ||
| 1517 | } | ||
| 1518 | else { | ||
| 1519 | Lab::Exception::CorruptParameter->throw( | ||
| 1520 | "Invalid FSK source '$in', should be INT or EXT\n"); | ||
| 1521 | return; | ||
| 1522 | } | ||
| 1523 | $self->write("FSK:SOUR $s"); | ||
| 1524 | } | ||
| 1525 | |||
| 1526 | |||
| 1527 | sub get_sweep_start_frequency { | ||
| 1528 | my $self = shift; | ||
| 1529 | return $self->query("FREQ:STAR?"); | ||
| 1530 | } | ||
| 1531 | |||
| 1532 | |||
| 1533 | sub get_sweep_stop_frequency { | ||
| 1534 | my $self = shift; | ||
| 1535 | return $self->query("FREQ:STOP?"); | ||
| 1536 | } | ||
| 1537 | |||
| 1538 | |||
| 1539 | sub set_sweep_start_frequency { | ||
| 1540 | my $self = shift; | ||
| 1541 | my $in = shift; | ||
| 1542 | |||
| 1543 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1544 | |||
| 1545 | if ( $f =~ /^ERR:/ ) { | ||
| 1546 | Lab::Exception::CorruptParameter->throw( | ||
| 1547 | "Invalid SWEEP start frequency '$in' $f\n"); | ||
| 1548 | return; | ||
| 1549 | } | ||
| 1550 | |||
| 1551 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1552 | if ( $f < 10e-3 || $f > 15e6 ) { | ||
| 1553 | Lab::Exception::CorruptParameter->throw( | ||
| 1554 | "SWEEP start frequency '$in' out of range (10mHz..15MHz)\n"); | ||
| 1555 | return; | ||
| 1556 | } | ||
| 1557 | } | ||
| 1558 | $self->write("FREQ:STAR $f"); | ||
| 1559 | } | ||
| 1560 | |||
| 1561 | |||
| 1562 | sub set_sweep_stop_frequency { | ||
| 1563 | my $self = shift; | ||
| 1564 | my $in = shift; | ||
| 1565 | |||
| 1566 | my $f = _parseNRf( $in, 'Hz' ); | ||
| 1567 | |||
| 1568 | if ( $f =~ /^ERR:/ ) { | ||
| 1569 | Lab::Exception::CorruptParameter->throw( | ||
| 1570 | "Invalid SWEEP stop frequency '$in' $f\n"); | ||
| 1571 | return; | ||
| 1572 | } | ||
| 1573 | |||
| 1574 | if ( $f ne 'MIN' && $f ne 'MAX' ) { | ||
| 1575 | if ( $f < 10e-3 || $f > 15e6 ) { | ||
| 1576 | Lab::Exception::CorruptParameter->throw( | ||
| 1577 | "SWEEP stop frequency '$in' out of range (10mHz..15MHz)\n"); | ||
| 1578 | return; | ||
| 1579 | } | ||
| 1580 | } | ||
| 1581 | $self->write("FREQ:STOP $f"); | ||
| 1582 | } | ||
| 1583 | |||
| 1584 | |||
| 1585 | sub get_sweep_spacing { | ||
| 1586 | my $self = shift; | ||
| 1587 | return $self->query("SWE:SPAC?"); | ||
| 1588 | } | ||
| 1589 | |||
| 1590 | |||
| 1591 | sub set_sweep_spacing { | ||
| 1592 | my $self = shift; | ||
| 1593 | my $in = shift; | ||
| 1594 | my $s; | ||
| 1595 | |||
| 1596 | if ( $in =~ /^\s*LIN/i ) { | ||
| 1597 | $s = 'LIN'; | ||
| 1598 | } | ||
| 1599 | elsif ( $in =~ /^\s*LOG/i ) { | ||
| 1600 | $s = 'LOG'; | ||
| 1601 | } | ||
| 1602 | else { | ||
| 1603 | Lab::Exception::CorruptParameter->throw( | ||
| 1604 | "invalid SWEEP spacing '$in', should be LIN or LOG\n"); | ||
| 1605 | return; | ||
| 1606 | } | ||
| 1607 | $self->write("SWE:SPAC $s"); | ||
| 1608 | } | ||
| 1609 | |||
| 1610 | |||
| 1611 | sub get_sweep_time { | ||
| 1612 | my $self = shift; | ||
| 1613 | return $self->query("SWE:TIME?"); | ||
| 1614 | } | ||
| 1615 | |||
| 1616 | |||
| 1617 | sub set_sweep_time { | ||
| 1618 | my $self = shift; | ||
| 1619 | my $in = shift; | ||
| 1620 | |||
| 1621 | my $t = _parseNRf( $in, 's' ); | ||
| 1622 | if ( $t =~ /ERR/i ) { | ||
| 1623 | Lab::Exception::CorruptParameter->throw( | ||
| 1624 | "Parse error in sweep time '$in': $t\n"); | ||
| 1625 | return; | ||
| 1626 | } | ||
| 1627 | if ( $t ne 'MIN' && $t ne 'MAX' ) { | ||
| 1628 | if ( $t < 1e3 || $t > 500 ) { | ||
| 1629 | Lab::Exception::CorruptParameter->throw( | ||
| 1630 | "SWEEP time '$in' out of range (1ms..500s)\n"); | ||
| 1631 | return; | ||
| 1632 | } | ||
| 1633 | } | ||
| 1634 | $self->write("SWE:TIME $t"); | ||
| 1635 | } | ||
| 1636 | |||
| 1637 | # parse a delimited set of strings, return an array of the strings | ||
| 1638 | |||
| 1639 | sub _parseStrings($) { | ||
| 1640 | my $str = shift; | ||
| 1641 | $str =~ s/^\s+//; | ||
| 1642 | $str .= ' ,' if $str !~ /,\s*$/; | ||
| 1643 | my $x; | ||
| 1644 | my (@results) = (); | ||
| 1645 | |||
| 1646 | while ( $str ne '' ) { | ||
| 1647 | if ( $str =~ /^\"(([^\"]|\"\")+)\"\s*,/i ) { | ||
| 1648 | $x = $1; | ||
| 1649 | $x =~ s/\"\"/"/g; | ||
| 1650 | $str = $POSTMATCH; | ||
| 1651 | push( @results, $x ); | ||
| 1652 | } | ||
| 1653 | elsif ( $str =~ /^\'(([^\']|\'\')+)\'\s*,/i ) { | ||
| 1654 | $x = $1; | ||
| 1655 | $x =~ s/\'\'/'/g; | ||
| 1656 | $str = $POSTMATCH; | ||
| 1657 | push( @results, $x ); | ||
| 1658 | } | ||
| 1659 | elsif ( $str =~ /^([^,]*[^,\s])\s*,/i ) { | ||
| 1660 | $x = $1; | ||
| 1661 | $str = $POSTMATCH; | ||
| 1662 | push( @results, $x ); | ||
| 1663 | } | ||
| 1664 | else { | ||
| 1665 | carp("problems parsing strings '$str'"); | ||
| 1666 | last; | ||
| 1667 | } | ||
| 1668 | $str =~ s/^\s+//; | ||
| 1669 | } | ||
| 1670 | return (@results); | ||
| 1671 | } | ||
| 1672 | |||
| 1673 | # parse a GPIB number with suffix, units | ||
| 1674 | # $result = _parseNRf($numberstring,$unit1[,$unit2,...]) | ||
| 1675 | # _parseNRf('maximum','foo) -> 'MAX' | ||
| 1676 | # _parseNRf('-3.7e+3kJ','j') -> -3.7e6 | ||
| 1677 | # _parseNRf('2.3ksec','s','sec') -> 2300 ('s' and 'sec' alternate units) | ||
| 1678 | # note special cases for suffixes: MHZ, MOHM, MA | ||
| 1679 | # if problem, string returned starts 'ERR: ..message...' | ||
| 1680 | # see IEEE std 488-2 7.7.3 | ||
| 1681 | |||
| 1682 | sub _parseNRf($\[$@];@) { | ||
| 1683 | my $in = shift; | ||
| 1684 | $in = shift if ref($in) eq 'HASH'; # $self->_parseNRf handling... | ||
| 1685 | my $un = shift; | ||
| 1686 | $un = '' unless defined $un; | ||
| 1687 | my $us; | ||
| 1688 | |||
| 1689 | if ( ref($un) eq 'ARRAY' ) { | ||
| 1690 | $us = $un; | ||
| 1691 | } | ||
| 1692 | elsif ( ref($un) eq 'SCALAR' ) { | ||
| 1693 | $us = [ $$un, @_ ]; | ||
| 1694 | } | ||
| 1695 | elsif ( ref($un) eq '' ) { | ||
| 1696 | $us = [ $un, @_ ]; | ||
| 1697 | } | ||
| 1698 | my $str = $in; | ||
| 1699 | |||
| 1700 | $str =~ s/^\s+//; | ||
| 1701 | $str =~ s/\s+$//; | ||
| 1702 | |||
| 1703 | if ( $str =~ /^MIN/i ) { | ||
| 1704 | return 'MIN'; | ||
| 1705 | } | ||
| 1706 | if ( $str =~ /^MAX/i ) { | ||
| 1707 | return 'MAX'; | ||
| 1708 | } | ||
| 1709 | |||
| 1710 | my $mant = 0; | ||
| 1711 | my $exp = 0; | ||
| 1712 | if ( $str =~ /^([+\-]?(\d+\.\d*|\d+|\d*\.\d+))\s*/i ) { | ||
| 1713 | $mant = $1; | ||
| 1714 | $str = $POSTMATCH; | ||
| 1715 | return $mant if $str eq ''; | ||
| 1716 | if ( $str =~ /^e\s*([+\-]?\d+)\s*/i ) { | ||
| 1717 | $exp = $1; | ||
| 1718 | $str = $POSTMATCH; | ||
| 1719 | } | ||
| 1720 | return $mant * ( 10**$exp ) if $str eq ''; | ||
| 1721 | |||
| 1722 | my $kexp = $exp; | ||
| 1723 | my $kstr = $str; | ||
| 1724 | foreach my $u ( @{$us} ) { | ||
| 1725 | $u =~ s/^\s+//; | ||
| 1726 | $u =~ s/\s+$//; | ||
| 1727 | |||
| 1728 | $str = $kstr; | ||
| 1729 | $exp = $kexp; | ||
| 1730 | if ( $u =~ /^db/i ) { # db(magnitude_suffix)?(V|W|... unit)? | ||
| 1731 | my $dbt = $POSTMATCH; | ||
| 1732 | if ( $str =~ /^dBex(${dbt})?$/i ) { | ||
| 1733 | $exp += 18; | ||
| 1734 | } | ||
| 1735 | elsif ( $str =~ /^dBpe(${dbt})?$/i ) { | ||
| 1736 | $exp += 15; | ||
| 1737 | } | ||
| 1738 | elsif ( $str =~ /^dBt(${dbt})?$/i ) { | ||
| 1739 | $exp += 12; | ||
| 1740 | } | ||
| 1741 | elsif ( $str =~ /^dBg(${dbt})?$/i ) { | ||
| 1742 | $exp += 9; | ||
| 1743 | } | ||
| 1744 | elsif ( $str =~ /^dBma(${dbt})$/i ) { | ||
| 1745 | $exp += 6; | ||
| 1746 | } | ||
| 1747 | elsif ( $str =~ /^dBk(${dbt})?$/i ) { | ||
| 1748 | $exp += 3; | ||
| 1749 | } | ||
| 1750 | elsif ( $str =~ /^dBm(${dbt})?$/i ) { | ||
| 1751 | $exp -= 3; | ||
| 1752 | } | ||
| 1753 | elsif ( $str =~ /^dBu(${dbt})?$/i ) { | ||
| 1754 | $exp -= 6; | ||
| 1755 | } | ||
| 1756 | elsif ( $str =~ /^dBn(${dbt})?$/i ) { | ||
| 1757 | $exp -= 9; | ||
| 1758 | } | ||
| 1759 | elsif ( $str =~ /^dBp(${dbt})?$/i ) { | ||
| 1760 | $exp -= 12; | ||
| 1761 | } | ||
| 1762 | elsif ( $str =~ /^dBf(${dbt})?$/i ) { | ||
| 1763 | $exp -= 15; | ||
| 1764 | } | ||
| 1765 | elsif ( $str =~ /^dB${dbt}$/i ) { | ||
| 1766 | $exp += 0; | ||
| 1767 | } | ||
| 1768 | else { | ||
| 1769 | next; | ||
| 1770 | } | ||
| 1771 | } | ||
| 1772 | else { # regular units stuff: (magnitude_suffix)(unit)? | ||
| 1773 | if ( $str =~ /^ex(${u})?$/i ) { | ||
| 1774 | $exp += 18; | ||
| 1775 | } | ||
| 1776 | elsif ( $str =~ /^pe(${u})?$/i ) { | ||
| 1777 | $exp += 15; | ||
| 1778 | } | ||
| 1779 | elsif ( $str =~ /^t(${u})?$/i ) { | ||
| 1780 | $exp += 12; | ||
| 1781 | } | ||
| 1782 | elsif ( $str =~ /^g(${u})?$/i ) { | ||
| 1783 | $exp += 9; | ||
| 1784 | } | ||
| 1785 | elsif ( $u =~ /(HZ|OHM)/i && $str =~ /^ma?(${u})$/i ) { | ||
| 1786 | $exp += 6; | ||
| 1787 | } | ||
| 1788 | elsif ( $u =~ /A/i && $str =~ /^ma$/i ) { | ||
| 1789 | $exp -= 3; | ||
| 1790 | } | ||
| 1791 | elsif ( $u !~ /(HZ|OHM)/i && $str =~ /^ma(${u})?$/i ) { | ||
| 1792 | $exp += 6; | ||
| 1793 | } | ||
| 1794 | elsif ( $str =~ /^k(${u})?$/i ) { | ||
| 1795 | $exp += 3; | ||
| 1796 | } | ||
| 1797 | elsif ( $str =~ /^m(${u})?$/i ) { | ||
| 1798 | $exp -= 3; | ||
| 1799 | } | ||
| 1800 | elsif ( $str =~ /^u(${u})?$/i ) { | ||
| 1801 | $exp -= 6; | ||
| 1802 | } | ||
| 1803 | elsif ( $str =~ /^n(${u})?$/i ) { | ||
| 1804 | $exp -= 9; | ||
| 1805 | } | ||
| 1806 | elsif ( $str =~ /^p(${u})?$/i ) { | ||
| 1807 | $exp -= 12; | ||
| 1808 | } | ||
| 1809 | elsif ( $str =~ /^f(${u})?$/i ) { | ||
| 1810 | $exp -= 15; | ||
| 1811 | } | ||
| 1812 | elsif ( $str =~ /^${u}$/i ) { | ||
| 1813 | $exp += 0; | ||
| 1814 | } | ||
| 1815 | else { | ||
| 1816 | next; | ||
| 1817 | } | ||
| 1818 | } | ||
| 1819 | return $mant * ( 10**$exp ); | ||
| 1820 | } | ||
| 1821 | } | ||
| 1822 | return "ERR: '$str' number parsing problem"; | ||
| 1823 | |||
| 1824 | } | ||
| 1825 | |||
| 1826 | 1; # End of Lab::Instrument::HP33120A | ||
| 1827 | |||
| 1828 | __END__ |