TestRF.com

# Main function
def main():
    # Get the Command Line parameters in first
    argv = sys.argv
 
    # Debug Args for testing various modes (overrides command line inputs)
    # Uncomment to use
    #argv = ["",""]
    #argv = ["-i","192.168.1.2", "-n","100","-b","ASCII","-f","iqdata.txt"]
    #argv = ["-i","192.168.1.2", "-n","1000000","-b","BIN","-f","iqdata.iqw","-a","1MHz"]
    #argv = ["-i","192.168.1.2", "-n","1000","-b","BIN","-f","iqdata.iqw","-a","1MHz"]
 
    # Check some arguments have been entered
    if len(argv) > 1 :
        if argv[1] == "-h":
            print "Program Usage:\n"
 
            #80 charachter line
            #-------------------------------------------------------------------------------
            print "This program captures IQ Data as IQ Pairs from R&S Spectrum Analysers"
            print "The data can then be easily manipulated and changed to a Waveform file"
            print "to run on an R&S signal generator by using Arb Toolbox (1GP62)\n"
 
            print "Command Examples:"
            print "fsxiqcapture.exe -h => Gives these instructions"
            print "fsxiqcapture.exe param1 param2 ...\n"
 
            print "-i   IP address e.g. -i 192.168.1.2"
            print "-f   Output File e.g. -f iqcapture.txt, default = iqcapture.txt"
            print "-b   Read Type e.g. -b BIN or -b ASCII, default = ASCII"
            print "-r   Resolution BW e.g. -r 10MHz, default = 10MHz"
            print "-t   Trigger setting e.g. -t IMM or -t EXT, default = IMM"
            print "-a   Sample Rate e.g. -a 10MHz, default = 10MHz"
            print "-n   No. Captured IQ Sample Pairs e.g. -n 2048, default = 2048"
            print "-d   Analyser Display On or Off e.g. -d ON or -d OFF, default = ON"
        else:
            # Process input args
            count = 0
 
            ipaddress = ""
            outfile = ""
            readtype = ""
            rbw = ""
            samprate = ""
            trigger = ""
            nosamples = ""
            dispupdate = ""
            vdebug = ""
 
            while count < len(argv):
                x = argv[count]
                if x == "-i":
                    ipaddress = argv[count+1]
                elif x == "-f":
                    outfile = argv[count+1]
                elif x == "-b":
                    readtype = argv[count+1].upper()
                elif x == "-r":
                    rbw = argv[count+1]
                elif x == "-t":
                    trigger = argv[count+1].upper()
                elif x == "-a":
                    samprate = argv[count+1]
                elif x == "-n":
                    nosamples = argv[count+1]
                elif x == "-d":
                    dispupdate = argv[count+1].upper()
                count += 1
 
            if ipaddress == "": ipaddress = "192.168.1.2"
            if readtype == "": readtype = "ASCII"
            if outfile == "": outfile = "iqcapture.txt"
            if rbw == "": rbw = "10MHz"
            if samprate == "": samprate = "10MHz"
            if trigger == "": trigger = "IMM"
            if nosamples == "": nosamples = "2048"
            if dispupdate == "": dispupdate = "ON"
 
            # Create an instance of the class and connect to the instruments
            fsx = scpicontrol.scpicontrol(timeout)
            fsx.connect(ipaddress,int(port))
 
            if fsx.connected == True:
                res = fsx.ask(debug,"*IDN?")
                if res != False:
                    print "Instrument Connected: " + res
                    print "RBW is: " + rbw
                    print "Trigger setting is: " + trigger
                    print "Sample Rate is: " + samprate
                    print "No. Samples requested: " + format(int(nosamples),",d")
                    print "Analyser Display is: " + dispupdate
 
                # Update the screen
                fsx.write(debug,"SYST:DISP:UPD " + dispupdate)
 
                # Continous sweep off so we can do synchronous reads
                fsx.write(debug,"INIT:CONT OFF")
 
                # Turn IQ capture ON
                fsx.write(debug,"TRAC:IQ:STAT ON")
 
                # Set RBW, Sample Rate, Trigger, tigger slope, pre-trig samples, no.samples
                fsx.write(debug,"TRAC:IQ:SET NORM,"+rbw+","+samprate+","+trigger+",POS,0,"+nosamples)
 
                # Get the IQ data
                # Create new IQReader Object
                iqr = iqreader.iqreader(fsx.handle)
                if readtype == "BIN":
                    fsx.write(debug,"FORM REAL,32")
                    fsx.write(debug,"TRACe:IQ:DATA:FORMat IQPair")
                    fsx.write(debug,"TRAC:IQ:DATA?")
                    iqr.biniqread(nosamples,outfile) 	# Read as binary
                elif readtype == "ASCII":
                    fsx.write(debug,"FORM ASCii")
                    fsx.write(debug,"TRACe:IQ:DATA:FORMat IQPair")
                    fsx.write(debug,"TRAC:IQ:DATA?")
                    iqr.asciiiqread(outfile)			# Read as ASCII
                    print "IQ saved to: " + outfile
 
                # Disconnect and close the socket
                if fsx.connected == True: fsx.disconnect()
    else:
        print "No Arguments Passed"
 
# Boilerplate syntax, call the main function
# Seems to significantly speed up script execution
if __name__ == "__main__":
	# Save the start time
    startTime = datetime.now()
    main()
    # Print script runtime
    print "Script Run Time: " + str(datetime.now()-startTime)

import socket           # Get the socket functions
 
class scpicontrol:
    """Class to control instruments via SCPI over a socket with error
     checking and use of multiple connections"""
 
    # Internal variable to track if connected
    connected = False
 
    def __init__(self, timeout):
        """Initiate the Class using a timeout value for the socket
        and create an internal handle for the socket connection"""
 
        socket.setdefaulttimeout(timeout)
        self.handle = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
    def connect(self,ip,port):
        """Connect to the instrument on IP and PORT"""
 
        try:
            self.handle.connect((ip,port))
            self.connected = True
            print "Connected OK to " + ip
            return True # Return OK if connected
        except:
            self.connected = False
            self.retry_connection(ip,port)
            return False
 
    def disconnect(self):
        """Disconnect from the instrument"""
 
        try:
            self.handle.close()
            self.connected = False
            print "Disconnected from Instrument"
            return True
        except:
            self.connected = False
            print "Error:  Failed to disconnect from instrument"
            return False
 
    def write(self,debug,msg):
        """Write SCPI message to instrument as ASCII string"""
 
        msg1 = msg+"\n"
        try:
            totalsent = 0
            while totalsent < len(msg1):
                sent = self.handle.send(msg1[totalsent:])
                if sent == 0:
                    raise RuntimeError("Socket Connection Broken")
                totalsent = totalsent + sent
            if debug == "ON":
                print "Message " + msg + " sent ok"
                result = self.ask(debug,"syst:err?")
                print ("Result: " + result)
            return True
        except:
            print "Error: Could not send the message " + msg + " to instrument..."
            self.connected = False
            return False
 
    def read(self):
        """Read data from instrument response as ASCII"""
 
        try:
            msg = ""
            finished = False
            while finished != True:
                chunk = self.handle.recv(1)
                if chunk == "\n":
                    finished = True
                if chunk == "":
                    raise RuntimeError("Socket Connection Broken")
                msg = msg + chunk.strip()
            return msg
        except:
            print "Error:  No answer from the instrument..."
            self.connected = False
            return False
 
    def ask(self,debug,msg):
        """Write command and read response from instrument"""
 
        if self.write(debug,msg) == True:
            res = self.read()
            if res != False:
                return res
 
    def retry_connection(self,ip,port):
        """Retry to connect to instrument if a problem occurs"""
 
        print "Not able to connect to " + ip
        res = raw_input("Retry to connect Y/n?\n")
        if res == "Y" or res == "y" or res == "":
            self.connect(ip,port)
        else:
            print ("OK, no problem.")

class iqreader:
    """Class to hande IQ reading from an R&S analyser in
       ASCII or Binary format"""
 
    def __init__(self,handle):
        """Initiate the Class"""
        self.handle = handle
 
    def asciiiqread(self,filename):
        """Read response as ASCII from instrument"""
 
        try:
            iqdata = ""
            finished = False
            asciifile = open (filename, "w")
            while finished != True:
                chunk = self.handle.recv(1)
                iqdata = iqdata + chunk.strip()
                if chunk == "\n":
                    finished = True
 
            iqdata = self.format_ascii_iqdata(iqdata)
            asciifile.write(iqdata)
            asciifile.close()
            return True
        except:
            print "Error:  No answer from the instrument..."
            self.connected = False
            return False
 
    def format_ascii_iqdata(self,iqdata):
        # split the iqdata on comma
        datalist = iqdata.split(",")
        samples = len(datalist)/2
        arrdata = ""
 
        counter = 0
        while counter < (samples*2):
            arrdata = arrdata + datalist[counter] + "," + datalist[counter+1] + "\n"
            counter = counter + 2
        return arrdata
 
    def biniqread(self,samples,filename):
        """Read response as BINARY from instrument"""
 
        try:
            # Read the first byte # from buffer
            self.handle.recv(1) 
 
            # Read num of digits to get for No of floats
            if int(samples) < 125000000:
                digits = self.handle.recv(1)
            else:
                self.handle.recv(1)
                digits = "10"
 
            # Read in how many bytes we have to get
            i = 0
            totalbytes = ""
            while i < int(digits):
                totalbytes = totalbytes + self.handle.recv(1)
                i += 1
 
            # Now read in the IQ data from the analyser memory
            # Write it to file as recieved
            binfile = open (filename, "wb")
            totbytes = int(totalbytes)
            nofloats = int(totalbytes)/4
            nosamples = int(totalbytes)/8
            buf = ""
            sampoutput = nosamples / 10
            i = 0
            count = 0
            while i = sampoutput:
                    print "Samples Read: " + format(i,",d")
                    count = 0
                count += 1
                i += 1
 
            binfile.close()
            return True
        except:
            print "Error: No answer from the instrument..."
            self.connected = False
            return False

// Allow the script to hang around waiting for connections
set_time_limit (0);
 
$fsq_ip_address = "192.168.1.2";
$debug = "OFF"
$port = 5025; 
 
// open socket to instrument
$fsq= fsockopen ($fsq_ip_address, $port, $errno, $errstr, 10); 
 
// open the output file for results
$fp = fopen ("output.txt", "w+"); 
 
// query instrument for its details and output result
writescpi($fsq,$debug, "*IDN?");
$result = readscpi($fsq);
logger("Instrument: " . $result); 
 
// close sockets and file
fclose ($fsq);
fclose ($fp); 
 
// Function Definitions
// Write string to the socket (output errors if debug enabled)
function writescpi($inst,$debug,$msg)
{
  fputs ($inst, $msg . "\n");
 
  if ($debug == true)
   {
    print ("\nCmd: " . $msg);
    fputs ($inst, "syst:err?\n");
    $result = readscpi($inst);
    print ("Result: " . $result . "\n");
  }
} 
 
// Read string from the socket
function readscpi($inst)
{
  $buf = fgets ($inst,100000);
  $buf = trim ($buf);
  return $buf;
} 
 
// output to screen and to file at the same time
function logger($result)
{
  global $fp;
  print ($result . "\n");
  fwrite ($fp, $result);
}