Agilent Signal Generators Programming Guide
113
Programming Examples
GPIB Programming Interface Examples
viPrintf(vi, "*CLS\n");// Clears signal generator status byte
viPrintf(vi, "STAT:OPER:NTR 8\n");// Sets the Operation Status Group  // Negative Transition Filter to 
indicate a  // negative transition in Bit 3 (Sweeping) 
// which will set a corresponding event in   // the Operation Event Register. This occurs   // at the end 
of a sweep. 
viPrintf(vi, "STAT:OPER:PTR 0\n");// Sets the Operation Status Group  // Positive Transition Filter so 
that no 
// positive transition on Bit 3 affects the  // Operation Event Register. The positive  // transition 
occurs at the start of a sweep.
viPrintf(vi, "STAT:OPER:ENAB 8\n");// Enables Operation Status Event Bit 3  // to report the event to 
Status Byte  // Register Summary Bit 7.
viPrintf(vi, "*SRE 128\n");// Enables Status Byte Register Summary Bit 7
// The next line of code indicates the  // function to call on an event 
viStatus = viInstallHandler(vi, VI_EVENT_SERVICE_REQ, interupt, rdBuffer);
// The next line of code enables the  // detection of an event
viStatus = viEnableEvent(vi, VI_EVENT_SERVICE_REQ, VI_HNDLR, VI_NULL);
viPrintf(vi, "FREQ:MODE LIST\n");// Sets frequency mode to list
viPrintf(vi, "LIST:TYPE STEP\n");// Sets sweep to step
viPrintf(vi, "LIST:TRIG:SOUR IMM\n");// Immediately trigger the sweep 
viPrintf(vi, "LIST:MODE AUTO\n");// Sets mode for the list sweep
viPrintf(vi, "FREQ:STAR 40 MHZ\n"); // Start frequency set to 40 MHz
viPrintf(vi, "FREQ:STOP 900 MHZ\n");// Stop frequency set to 900 MHz
viPrintf(vi, "SWE:POIN 25\n");// Set number of points for the step sweep
viPrintf(vi, "SWE:DWEL .5 S\n");// Allow .5 sec dwell at each point
viPrintf(vi, "INIT:CONT OFF\n");// Set up for single sweep
viPrintf(vi, "TRIG:SOUR IMM\n");// Triggers the sweep 
viPrintf(vi, "INIT\n");  // Takes a single sweep
printf("\n");
// While the instrument is sweeping have the
// program busy with printing to the display.
// The Sleep function, defined in the header
// file windows.h, will pause the program
// operation for .5 seconds
while (sweep==1){
printf("*");
Sleep(500);}
printf("\n");
// The following lines of code will stop the
// events and close down the session
viStatus = viDisableEvent(vi, VI_ALL_ENABLED_EVENTS,VI_ALL_MECH);
viStatus = viUninstallHandler(vi, VI_EVENT_SERVICE_REQ, interupt, 
rdBuffer);
viStatus = viClose(vi);
Batch pdf to jpg converter online - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
bulk pdf to jpg; convert pdf to gif or jpg
Batch pdf to jpg converter online - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
changing file from pdf to jpg; change pdf file to jpg file
114
Agilent Signal Generators Programming Guide
Programming Examples
GPIB Programming Interface Examples
viStatus = viClose(defaultRM);
return 0;
}
// The following function is called when an SRQ event occurs. Code specific to your 
// requirements would be entered in the body of the function.
ViStatus _VI_FUNCH interupt(ViSession vi, ViEventType eventType, ViEvent event, ViAddr 
addr)
{
ViStatus status;
ViUInt16 stb;
status = viReadSTB(vi, &stb);// Reads the Status Byte
sweep=0;// Sets the flag to stop the ’*’ printing
printf("\n");// Print user information
printf("An SRQ, indicating end of sweep has occurred\n");
viClose(event);// Closes the event
return VI_SUCCESS;
}
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
software; Support a batch conversion of JPG to PDF with amazingly high speed; Get a compressed PDF file after conversion; Support
convert pdf to jpg; convert pdf to 300 dpi jpg
JPG to GIF Converter | Convert JPEG to GIF, Convert GIF to JPG
Features and Benefits. High speed JPEG to GIF Converter, faster than other JPG Converters; file name when you convert the files in batch; Storing conversion
convert pdf to jpg for online; pdf to jpeg
Agilent Signal Generators Programming Guide
115
Programming Examples
GPIB Programming Interface Examples
Using 8757D Pass-Thru Commands (PSG with Option 007 Only)
Pass-thru commands enable you to send operating instructions to a PSG or E8257N that is connected 
to a 8757D scalar analyzer system. This section provides setup information and an example program 
for using pass-thru commands in a ramp sweep system.
Equipment Setup
To send pass-thru commands, set up the equipment as shown in Figure 3-1. Notice that the GPIB 
cable from the computer is connected to the GPIB interface bus of the 8757D. The GPIB cable from 
the PSG or E8257N is connected to the system interface bus of the 8757D.
Figure 3-1
JPG to DICOM Converter | Convert JPEG to DICOM, Convert DICOM to
Open JPEG to DICOM Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "DICOM" in
change pdf into jpg; convert .pdf to .jpg online
JPG to JBIG2 Converter | Convert JPEG to JBIG2, Convert JBIG2 to
Open JPEG to JBIG2 Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "JBIG2" in
convert pdf to jpg file; .pdf to .jpg converter online
116
Agilent Signal Generators Programming Guide
Programming Examples
GPIB Programming Interface Examples
GPIB Address Assignments
Figure 3-1 describes how GPIB addresses should be assigned for sending pass-thru commands. These 
are the same addresses used in Example 3-1.
Example Pass-Thru Program
Example 3-1 on page 116 is a sample Agilent BASIC program that switches the 8757D to pass-thru 
mode, allowing you to send operating commands to the PSG. After the program runs, control is given 
back to the network analyzer. The following describes the command lines used in the program.
Line 30  
PT is set to equal the source address. C1 is added, but not needed, to specify the 
channel.
Lines 40, 90  
The END statement is required to complete the language transition.
Lines 50, 100  
A WAIT statement is recommended after a language change to allow all instrument 
changes to be completed before the next command.
Lines 70, 80  
This is added to ensure that the instrument has completed all operations before 
switching languages. Lines 70 and 80 can only be used when the signal generator 
is in single sweep mode.
Line 110  
This takes the network analyzer out of pass-thru command mode, and puts it back 
in control. Any analyzer command can now be entered.
NOTE
Verify the signal generator is in single sweep mode. Refer to the SCPI Command Reference 
or the User’s Guide, as required.
Example 3-1 1 Pass-Thru Program
10 ABORT 7
20 CLEAR 716
30 OUTPUT 716;"PT19;C1"
Table 3-1
Instrument
GPIB 
Address
Key Presses/Description
PSG/E8663B
19
Press Utility > GPIB/RS-232 LAN > GPIB Address > 19 > Enter.
8757D
16
Press LOCAL > 8757 > 16 > Enter.
8757D (Sweeper)
19
This address must match the PSG.
Press LOCAL > SWEEPER > 19 > Enter.
Pass Thru
17
The pass thru address is automatically selected by the 8757D by inverting 
the last bit of the 8757D address. Refer to the 8757D documentation for 
more information. Verify that no other instrument is using this address 
on the GPIB bus.
JPG to JPEG2000 Converter | Convert JPEG to JPEG2000, Convert
Open JPEG to JPEG2000 Converter first; ad JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "JPEG2000" in
reader pdf to jpeg; best pdf to jpg converter for
JPG to Word Converter | Convert JPEG to Word, Convert Word to JPG
Open JPEG to Word Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "Word" in
.pdf to jpg converter online; convert online pdf to jpg
Agilent Signal Generators Programming Guide
117
Programming Examples
GPIB Programming Interface Examples
40 OUTPUT 717;"SYST:LANG SCPI";END
50 WAIT .5
60 OUTPUT 717;"OUTP:STAT OFF"
70 OUTPUT 717;"*OPC?"
80 ENTER 717; Reply
90 OUTPUT 717;"SYST:LANG COMP";END
100 WAIT .5
110 OUTPUT 716;"C2"
120 END 
Setting the PSG Sweep Time Requirements (PSG with Firmware 4.92)
By default, the PSG sweep time is automatically adjusted to the fastest possible sweep when exiting 
Pass-Thru mode. To disable this feature and retain specific time selection, set the 8757D system time 
to Manual.
The front panel key sequence is:
Sweep > Sweep Type > 8757D System Sweep Time to Manual 
The SCPI command sequence is:
[:SOURce]:SWEep:TIME:COMP:AUTO OFF
NOTE
The changes to sweep time mode are persistent. For more information on persistent memory, 
refer to the User’s Guide. 
The SCPI command to set up sweep time is: :SWE:TIME <val><units>.
For more on SCPI commands, refer to the SCPI Command Reference.
Setting the PSG Sweep Time Requirements (PSG with Firmware 4.91)
By default, the PSG sweep time is automatically adjusted to the fastest possible sweep when exiting 
Pass-Thru mode. To select a different sweep time, these additional steps are required:
1. Insert line 25, that saves state 1 (SV1).
25 OUTPUT 716;”SV1”
2. Insert line 55, that sets the sweep-time of the source, :SWE:TIME <val>.
55 OUTPUT 717;”:SWE:TIME .200S”
3. Insert line 56, that saves the state into the register, sequence 0, register 1, *SAV 
<reg_num>[,<seq_num>], (*SAV 1,0).
56 OUTPUT 717;”*SAV 1,0”
JPG to PNG Converter | Convert JPEG to PNG, Convert PNG to JPG
Open JPEG to PNG Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "PNG" in "Output
convert multi page pdf to single jpg; changing pdf to jpg file
VB.NET Image: PDF to Image Converter, Convert Batch PDF Pages to
RasterEdge .NET Imaging PDF Converter makes it non-professional end users to convert PDF and PDF/A documents commonly in daily life (like tiff, jpg, png, bitmap
convert pdf to jpeg; convert pdf images to jpg
118
Agilent Signal Generators Programming Guide
Programming Examples
LAN Programming Interface Examples
4. Insert line 115, that recalls state 1, (RC1).
115 OUTPUT 717;”RC1”
LAN Programming Interface Examples
NOTE
The LAN programming examples in this section demonstrate the use of VXI-11 and Sockets 
LAN to control the signal generator. 
To use these programming examples you must change references to the IP address and 
hostname to match the IP address and hostname of your signal generator. 
• “VXI-11 Programming Using SICL and C++” on page 119
• “VXI-11 Programming Using VISA and C++” on page 120
• “Sockets LAN Programming and C” on page 122
• “Sockets LAN Programming Using Java” on page 145
• “Sockets LAN Programming Using Perl” on page 147
• “TCP-IP (LAN) Programming Using Matlab” on page 148
For additional LAN programming examples that work with user-data files, refer to:
• “Save and Recall Instrument State Files” on page 363
VXI-11 Programming
The signal generator supports the VXI-11 standard for instrument communication over the LAN 
interface. Agilent IO Libraries support the VXI-11 standard and must be installed on your computer 
before using the VXI-11 protocol. Refer to “Using VXI–11” on page 44 for information on configuring 
and using the VXI-11 protocol.
The VXI-11 examples use TCPIP0 as the board address.
Using VXI-11 with GPIB Programs 
The GPIB programming examples that use the VISA library, and are listed in “GPIB Programming 
Interface Examples” on page 80, can be easily changed to use the LAN VXI-11 protocol by changing 
the address string. For example, change the "GPIB::19::INSTR" address string to 
"TCPIP::hostname::INSTR" where hostname is the IP address or hostname of the signal generator. The 
VXI-11 protocol has the same capabilities as GPIB. See the section “Setting Up the LAN Interface” on 
page 34 for more information.
NOTE
To communicate with the signal generator over the LAN interface you must enable the 
VXI-11 SCPI service. For more information, refer to “Configuring the VXI–11 for LAN 
(Agilent X-Series and MXG)” on page 34 and “Configuring the VXI–11 for LAN (ESG/PSG)” 
on page 35.
Agilent Signal Generators Programming Guide
119
Programming Examples
LAN Programming Interface Examples
VXI-11 Programming Using SICL and C++
The following program uses the VXI-11 protocol and SICL to control the signal generator. Before 
running this code, you must set up the interface using the Agilent IO Libraries IO Config utility. 
vxisicl.cpp performs the following functions:
• sets signal generator to 1 GHz CW frequency
• queries signal generator for an ID string
• error checking
The following program example is available on the signal generator Documentation CD-ROM as 
vxisicl.cpp.
//****************************************************************************************
// 
// PROGRAM NAME:vxisicl.cpp
//
// PROGRAM DESCRIPTION:Sample test program using SICL and the VXI-11 protocol
// 
// NOTE: You must have the Agilent IO Libraries installed to run this program.
// 
// This example uses the VXI-11 protocol to set the signal generator for a 1 gHz CW // frequency. The 
signal generator is queried for operation complete and then queried
// for its ID string. The frequency and ID string are then printed to the display. 
//
// IMPORTANT: Enter in your signal generators hostname in the instrumentName declaration
// where the "xxxxx" appears.
// 
//**************************************************************************************** 
#include "stdafx.h" 
#include <sicl.h> 
#include <stdlib.h> 
#include <stdio.h>
int main(int argc, char* argv[]) 
INST id;                                      // Device session id 
int opcResponse;                              // Variable for response flag                          
char instrumentName[] = "xxxxx"; // Put your instrument's hostname here
char instNameBuf[256];// Variable to hold instrument name
char buf[256];// Variable for id string
ionerror(I_ERROR_EXIT);// Register SICL error handler
120
Agilent Signal Generators Programming Guide
Programming Examples
LAN Programming Interface Examples
// Open SICL instrument handle using VXI-11 protocol
sprintf(instNameBuf, "lan[%s]:inst0", instrumentName); 
id = iopen(instNameBuf);// Open instrument session
itimeout(id, 1000);// Set 1 second timeout for operations
printf("Setting frequency to 1 Ghz...\n"); 
iprintf(id, "freq 1 GHz\n");// Set frequency to 1 GHz  
printf("Waiting for source to settle...\n"); 
iprintf(id, "*opc?\n");// Query for operation complete
iscanf(id, "%d", &opcResponse);  // Operation complete flag 
if (opcResponse != 1)// If operation fails, prompt user
printf("Bad response to 'OPC?'\n"); 
iclose(id); 
exit(1); 
iprintf(id, "FREQ?\n");// Query the frequency
iscanf(id, "%t", &buf);// Read the signal generator frequency
printf("\n");// Print the frequency to the display
printf("Frequency of signal generator is  %s\n", buf);
ipromptf(id, "*IDN?\n", "%t", buf);// Query for id string 
printf("Instrument ID: %s\n", buf);// Print id string to display 
iclose(id);// Close the session 
return 0; 
}
VXI-11 Programming Using VISA and C++
The following program uses the VXI-11 protocol and the VISA library to control the signal generator. 
The signal generator is set to a –5 dBm power level and queried for its ID string. Before running this 
code, you must set up the interface using the Agilent IO Libraries IO Config utility. vxivisa.cpp 
performs the following functions:
• sets signal generator to a –5 dBm power level
• queries signal generator for an ID string
• error checking
The following program example is available on the signal generator Documentation CD-ROM as 
vxivisa.cpp.
//****************************************************************************************
// PROGRAM FILE NAME:vxivisa.cpp
// Sample test program using the VISA libraries and the VXI-11 protocol
// 
Agilent Signal Generators Programming Guide
121
Programming Examples
LAN Programming Interface Examples
// NOTE: You must have the Agilent Libraries installed on your computer to run
// this program
// 
// PROGRAM DESCRIPTION:This example uses the VXI-11 protocol and VISA to query 
// the signal generator for its ID string. The ID string is then printed to the 
// screen. Next the signal generator is set for a -5 dBm power level and then
// queried for the power level. The power level is printed to the screen. 
// 
// IMPORTANT: Set up the LAN Client using the IO Config utility
//
//****************************************************************************************  
#include <visa.h>
#include <stdio.h>
#include "StdAfx.h"
#include <stdlib.h>
#include <conio.h>
#define MAX_COUNT 200
int main (void)
{
ViStatus status;// Declares a type ViStatus variable
ViSession defaultRM, instr;// Declares a type ViSession variable
ViUInt32 retCount;// Return count for string I/O
ViChar buffer[MAX_COUNT];// Buffer for string I/O
status = viOpenDefaultRM(&defaultRM);    // Initialize the system
// Open communication with Serial 
// Port 2
status = viOpen(defaultRM, "TPCIP0::19::INSTR", VI_NULL, VI_NULL, &instr);
if(status){                              // If problems then prompt user 
printf("Could not open ViSession!\n");
printf("Check instruments and connections\n");
printf("\n");
exit(0);}
// Set timeout for 5 seconds
viSetAttribute(instr, VI_ATTR_TMO_VALUE, 5000); 
// Ask for sig gen ID string
122
Agilent Signal Generators Programming Guide
Programming Examples
LAN Programming Interface Examples
status = viWrite(instr, (ViBuf)"*IDN?\n", 6, &retCount);
// Read the sig gen response 
status = viRead(instr, (ViBuf)buffer, MAX_COUNT, &retCount);
buffer[retCount]= '\0';                  // Indicate the end of the string
printf("Signal Generator ID = ");        // Print header for ID
printf(buffer);                          // Print the ID string 
printf("\n");                            // Print carriage return
// Flush the read buffer
// Set sig gen power to -5dbm
status = viWrite(instr, (ViBuf)"POW:AMPL -5dbm\n", 15, &retCount);
// Query the power level
status = viWrite(instr, (ViBuf)"POW?\n",5,&retCount);
// Read the power level
status = viRead(instr, (ViBuf)buffer, MAX_COUNT, &retCount);
buffer[retCount]= '\0';                  // Indicate the end of the string
printf("Power level = ");                // Print header to the screen
printf(buffer);                          // Print the queried power level
printf("\n");
status = viClose(instr);                 // Close down the system
status = viClose(defaultRM);
return 0;
}
Sockets LAN Programming and C
The program listing shown in “Queries for Lan Using Sockets” on page 125 consists of two files; 
lanio.c and getopt.c. The lanio.c file has two main functions; int main() and an int main1(). 
The int main() function allows communication with the signal generator interactively from the 
command line. The program reads the signal generator's hostname from the command line, followed 
by the SCPI command. It then opens a socket to the signal generator, using port 5025, and sends the 
command. If the command appears to be a query, the program queries the signal generator for a 
response, and prints the response. 
The int main1(), after renaming to int main(), will output a sequence of commands to the signal 
generator. You can use the format as a template and then add your own code.
This program is available on the signal generator Documentation CD-ROM as lanio.c.
Sockets on UNIX
In UNIX, LAN communication through sockets is very similar to reading or writing a file. The only 
difference is the openSocket() routine, which uses a few network library routines to create the 
TCP/IP network connection. Once this connection is created, the standard fread() and fwrite() 
routines are used for network communication. The following steps outline the process:
1. Copy the lanio.c and getopt.c files to your home UNIX directory. For example, /users/mydir/.
Documents you may be interested
Documents you may be interested