Instrument/HP33120A.pm untested

filter: Statementstmt 0.0% 0 / 904 Branchbran 0.0% 0 / 488 Conditioncond 0.0% 0 / 204 MC/DCmcdc 0.0% 0 / 126 Subroutinesub 0.0% 0 / 95 Podpod 0.0% 0 / 88 totaltotal 0.0% 0 / 1905 CC 245 SCAR 54.8
CC
245
Cov
0%
_parseNRf
1560.0
set_amplitude
272.0
load_waveform
272.0
CRAP 239.2
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__