# http://www.devshed.com/c/a/Python/Basic-Threading-in-Python/2/

import Queue
import socket
import threading
import string as sg
# *********** Turn simulation on here ***********
#SIMULATE = True
SIMULATE = False
if not SIMULATE :
    from agilentE8257D import *
    from agilent8648C import *
    from agilent33220 import *
    from hp11713A import *

#HOST = 'polaris.cv.nrao.edu'
HOST = socket.gethostname()
print 'host name: %s' % HOST
PORT = 50006

class ServerThread ( threading.Thread ):

    def __init__ ( self, parent ) :
        self.parent = parent
        threading.Thread.__init__ ( self )

    def run ( self ):
        while True:
            client = self.parent.serverPool.get()
            if client != None:
#                print 'Received connection:', client[1][0]
#                client[0].send ( 'xxx' )
                msg = client[0].recv(1024)
                self.parent.process_message(msg, client[0])
                client[0].close()

class GPIBserver :

    def __init__ ( self ) :
        self.buffer = ''
        if not SIMULATE :
# original LO1: 8257D
            self.lo1 = Agilent8648C(19)        #- 8648D - 3.2 GHz gen.
            self.default_lo1()
# original lo2: 8648B
            self.lo2 = Agilent8648C(20)        #- 8648B - 3.2 GHz gen.
            self.default_lo2()
# original sample clock: 8648B
            self.sample_clk = Agilent8648C(21) #- 8648C - 3.2 GHz gen.
            self.default_sample_clk()
# original cal: 8648C
#            self.cal = AgilentE8257D(26)       #- E8257D - 20 GHz sweeper
#            self.default_cal()
# original tone burst: 33220A
            self.tone_burst = Agilent33220(22) #- 33220A - 20 MHz function gen.
            self.default_tone_burst()
# original trigger pulse: 33220A
# original switch: 11713A ?
#            self.switch = HP11713A(17)         #- HP11713 - Atten./Switch Dr.
        self.serverPool = Queue.Queue(0)
        for x in xrange ( 2 ):
            ServerThread(self).start()
        server = socket.socket ( socket.AF_INET, socket.SOCK_STREAM )
        server.bind((HOST,PORT))
        server.listen(5)
        while True:
#            print '' #'RESTART'
            self.serverPool.put(server.accept())

    def default_lo1 ( self ) :
        # originally 2038.8125 MHz, -6.4 dBm
        self.lo1.reset_to_default ()
        self.lo1.set_output_power(7.0)
        self.lo1.disable_rf_output()
        self.lo1.enable_atten_ctrl()
        self.lo1.disable_reference_output()
        self.lo1.set_frequency(1820.0)
        self.lo1.disable_reference_frequency()
        self.lo1.disable_ampl_mod()
        self.lo1.disable_freq_mod()
        self.lo1.disable_phase_mod()
        self.lo1.disable_pulse_mod()

    def default_lo2 ( self ) :
        # originally 396 MHz, +8.5 dBm
        self.lo2.reset_to_default ()
        self.lo2.set_output_power(7.0)
        self.lo2.disable_rf_output()
        self.lo2.enable_atten_ctrl()
        self.lo2.disable_reference_output()
        self.lo2.set_frequency(396.0)
        self.lo2.disable_reference_frequency()
        self.lo2.disable_ampl_mod()
        self.lo2.disable_freq_mod()
        self.lo2.disable_phase_mod()
        self.lo2.disable_pulse_mod()

    def default_sample_clk ( self ) :
        # originlly 2.5 MHz, 0 dBm
        self.sample_clk.reset_to_default ()
        self.sample_clk.set_output_power(0.0)
        self.sample_clk.disable_rf_output()
        self.sample_clk.enable_atten_ctrl()
        self.sample_clk.disable_reference_output()
        self.sample_clk.set_frequency(2.5)
        self.sample_clk.disable_reference_frequency()
        self.sample_clk.disable_ampl_mod()
        self.sample_clk.disable_freq_mod()
        self.sample_clk.disable_phase_mod()
        self.sample_clk.disable_pulse_mod()

    def default_cal ( self ) :
        self.cal.reset_to_default ()
        self.cal.set_output_power(-30.0)
        self.cal.disable_rf_output()
        self.cal.enable_atten_ctrl()
        self.cal.disable_reference_output()
        self.cal.set_frequency(1500.0)
        self.cal.disable_reference_frequency()
        self.cal.disable_ampl_mod()
        self.cal.disable_freq_mod()
        self.cal.disable_phase_mod()
        self.cal.disable_pulse_mod()

    def default_tone_burst ( self ) :
        # originally 200 kHz, 200 cycles, 10 VPP, 0V offset
        self.tone_burst.reset()
        self.tone_burst.set_output('ON')
        self.tone_burst.set_function('SIN')
        self.tone_burst.set_frequency(2.0e5)
        self.tone_burst.set_voltage(10.0)
        self.tone_burst.set_voltage_unit('VPP')
        self.tone_burst.set_voltage_offset(0.0)
        self.tone_burst.set_trigger_source('IMM')
        self.tone_burst.set_burst_mode('TRIG')
        self.tone_burst.set_burst_cycles(200.0)
        self.tone_burst.set_burst_period(500.0)
        self.tone_burst.set_burst_phase(0.0)
        self.tone_burst.set_phase_unit('DEG')
        self.tone_burst.set_burst_state('ON')

    def process_message ( self, message, client ) :
#        print 'msg:', message
        self.buffer, commands = self.buffer_manager(self.buffer, message)
        for cmd in commands :
            words = cmd.split('(')
            cmd_name = words[0].strip()
            args = words[1].split(')')[0].split(',')
            if cmd_name == 'get_lo1' :
                self.get_lo1(client)
            elif cmd_name == 'set_lo1' :
                self.set_lo1(args, client)
            elif cmd_name == 'set_lo1_freq' :
                self.set_lo1_freq(args, client)
            elif cmd_name == 'set_lo1_power' :
                self.set_lo1_power(args, client)
            elif cmd_name == 'set_lo1_status' :
                self.set_lo1_status(args, client)
            elif cmd_name == 'get_lo2' :
                self.get_lo2(client)
            elif cmd_name == 'set_lo2' :
                self.set_lo2(args)
            elif cmd_name == 'set_lo2_freq' :
                self.set_lo2_freq(args, client)
            elif cmd_name == 'set_lo2_power' :
                self.set_lo2_power(args, client)
            elif cmd_name == 'set_lo2_status' :
                self.set_lo2_status(args, client)
            elif cmd_name == 'get_sample_clk' :
                self.get_sample_clk(client)
            elif cmd_name == 'set_sample_clk' :
                self.set_sample_clk(args)
            elif cmd_name == 'set_sample_clk_freq' :
                self.set_sample_clk_freq(args, client)
            elif cmd_name == 'set_sample_clk_power' :
                self.set_sample_clk_power(args, client)
            elif cmd_name == 'set_sample_clk_status' :
                self.set_sample_clk_status(args, client)
            elif cmd_name == 'get_cal' :
                self.get_cal(client)
            elif cmd_name == 'set_cal' :
                self.set_cal(args)
            elif cmd_name == 'set_cal_freq' :
                self.set_cal_freq(args, client)
            elif cmd_name == 'set_cal_power' :
                self.set_cal_power(args, client)
            elif cmd_name == 'set_cal_status' :
                self.set_cal_status(args, client)
            elif cmd_name == 'get_tone_burst' :
                self.get_tone_burst(client)
            elif cmd_name == 'set_tone_burst' :
                self.set_tone_burst(args)
            elif cmd_name == 'set_tone_burst_freq' :
                self.set_tone_burst_freq(args, client)
            elif cmd_name == 'set_tone_burst_voltage' :
                self.set_tone_burst_voltage(args, client)
            elif cmd_name == 'set_tone_burst_offset' :
                self.set_tone_burst_offset(args, client)
            elif cmd_name == 'set_tone_burst_cycles' :
                self.set_tone_burst_cycles(args, client)
            elif cmd_name == 'set_tone_burst_status' :
                self.set_tone_burst_status(args, client)
            elif cmd_name == 'get_switch' :
                self.get_switch(client)
            elif cmd_name == 'set_switch' :
                self.set_switch(args)
            else :
                self.send_error('Unknown GPIB command: %s' % cmd, client)

    def get_lo1 ( self, client ) :
        if not SIMULATE :
            freq = sg.atof(self.lo1.get_frequency()) * 1e-6
            power = sg.atof(self.lo1.get_output_power())
            if self.lo1.get_rf_output_status() == '1' :
                status = 'ON'
            else :
                status = 'OFF'
        else :
            freq = 1200.345
            power = +8.44
            status = 'ON'
        power = sg.atof(power)
        client.send('%10.6f,%5.2f,%s' % (freq, power, status))

    def set_lo1 ( self, args, client ) :
        if len(args) != 3 :
            self.send_error('set_lo1 needs 3 arguments, %d given' % len(args),
                            client)
            return
        freq = sg.atof(args[0])
        power = sg.atof(args[1])
        status = args[2].strip()
        if not SIMULATE :
            self.lo1.set_frequency(freq)
            self.lo1.set_output_power(power)
            if status == 'ON' :
                self.lo1.enable_rf_output()
            else :
                self.lo1.disable_rf_output()
        else :
            print 'lo1.set_frequency(%7.4f)' % freq
            print 'lo1.set_output_power(%+4.2f)' % power
            if status == 'ON' :
                print 'lo1.enable_rf_output()'
            else :
                print 'lo1.disable_rf_output()'
        self.send_ok(client)

    def set_lo1_freq ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo1_freq needs 1 argument, %d given' % \
                                len(args), client)
            return
        freq = sg.atof(args[0])
        if not SIMULATE :
            self.lo1.set_frequency(freq)
        else :
            print 'lo1.set_frequency(%7.4f)' % freq
        self.send_ok(client)

    def set_lo1_power ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo1_power needs 1 argument, %d given' \
                                % len(args), client)
            return
        power = sg.atof(args[0])
        if not SIMULATE :
            self.lo1.set_output_power(power)
        else :
            print 'lo1.set_output_power(%+4.2f)' % power
        self.send_ok(client)

    def set_lo1_status ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo1_status needs 1 argument, %d given' \
                                % len(args), client)
            return
        status = args[0].strip()
        if not SIMULATE :
            if status == 'ON' :
                self.lo1.enable_rf_output()
            else :
                self.lo1.disable_rf_output()
        else :
            if status == 'ON' :
                print 'lo1.enable_rf_output()'
            else :
                print 'lo1.disable_rf_output()'
        self.send_ok(client)

    def get_lo2 ( self, client ) :
        if not SIMULATE :
            freq = sg.atof(self.lo2.get_frequency()) * 1e-6
            power = sg.atof(self.lo2.get_output_power())
            if self.lo2.get_rf_output_status() == '1' :
                status = 'ON'
            else :
                status = 'OFF'
        else :
            freq = 255.666
            power = +8.99
            status = 'ON'
        client.send('%10.6f,%5.2f,%s' % (freq, power, status))

    def set_lo2 ( self, args, client ) :
        if len(args) != 3 :
            self.send_error('set_lo2 needs 3 arguments, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        power = sg.atof(args[1])
        status = args[2]
        if not SIMULATE :
            self.lo2.set_frequency(freq)
            self.lo2.set_output_power(power)
            if status == 'ON' :
                self.lo2.enable_rf_output()
            else :
                self.lo2.disable_rf_output()
        else :
            print 'lo2.set_frequency(%7.4f)' % freq
            print 'lo2.set_output_power(%+4.2f)' % power
            if status == 'ON' :
                print 'lo2.enable_rf_output()'
            else :
                print 'lo2.disable_rf_output()'
        self.send_ok(client)

    def set_lo2_freq ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo2_freq needs 1 argument, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        if not SIMULATE :
            self.lo2.set_frequency(freq)
        else :
            print 'lo2.set_frequency(%7.4f)' % freq
        self.send_ok(client)

    def set_lo2_power ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo2_power needs 1 argument, %d given' \
                                % len(args), client)
            return
        power = sg.atof(args[0])
        if not SIMULATE :
            self.lo2.set_output_power(power)
        else :
            print 'lo2.set_output_power(%+4.2f)' % power
        self.send_ok(client)

    def set_lo2_status ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_lo2_status needs 1 argument, %d given' \
                                % len(args), client)
            return
        status = args[0].strip()
        if not SIMULATE :
            if status == 'ON' :
                self.lo2.enable_rf_output()
            else :
                self.lo2.disable_rf_output()
        else :
            if status == 'ON' :
                print 'lo2.enable_rf_output()'
            else :
                print 'lo2.disable_rf_output()'
        self.send_ok(client)

    def get_sample_clk ( self, client ) :
        if not SIMULATE :
            freq = sg.atof(self.sample_clk.get_frequency()) * 1e-6
            power = sg.atof(self.sample_clk.get_output_power())
            if self.sample_clk.get_rf_output_status() == '1' :
                status = 'ON'
            else :
                status = 'OFF'
        else :
            freq = 20.0
            power = +4.88
            status = 'ON'
        client.send('%10.6f,%5.2f,%s' % (freq, power, status))

    def set_sample_clk ( self, args, client ) :
        if len(args) != 3 :
            self.send_error('set_sample_clk needs 3 arguments, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        power = sg.atof(args[1])
        status = args[2]
#        print '____', status
        if not SIMULATE :
            self.sample_clk.set_frequency(freq)
            self.sample_clk.set_output_power(power)
            if status == 'ON' :
                self.sample_clk.enable_rf_output()
            else :
                self.sample_clk.disable_rf_output()
        else :
            print 'sample_clk.set_frequency(%7.4f)' % freq
            print 'sample_clk.set_output_power(%+4.2f)' % power
            if status == 'ON' :
                print 'sample_clk.enable_rf_output()'
            else :
                print 'sample_clk.disable_rf_output()'
        self.send_ok(client)

    def set_sample_clk_freq ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_sample_clk_freq needs 1 argument, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        if not SIMULATE :
            self.sample_clk.set_frequency(freq)
        else :
            print 'sample_clk.set_frequency(%7.4f)' % freq
        self.send_ok(client)

    def set_sample_clk_power ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_sample_clk_power needs 1 argument, %d given' \
                                % len(args), client)
            return
        power = sg.atof(args[0])
        if not SIMULATE :
            self.sample_clk.set_output_power(power)
        else :
            print 'sample_clk.set_output_power(%+4.2f)' % power
        self.send_ok(client)

    def set_sample_clk_status ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_sample_clk_status needs 1 argument, %d given' \
                                % len(args), client)
            return
        status = args[0].strip()
        if not SIMULATE :
            if status == 'ON' :
                self.sample_clk.enable_rf_output()
            else :
                self.sample_clk.disable_rf_output()
        else :
            if status == 'ON' :
                print 'sample_clk.enable_rf_output()'
            else :
                print 'sample_clk.disable_rf_output()'
        self.send_ok(client)

    def get_cal ( self, client ) :
        if not SIMULATE :
            freq = sg.atof(self.cal.get_frequency()) * 1e-6
            power = sg.atof(self.cal.get_output_power())
            if self.cal.get_rf_output_status() == '1' :
                status = 'ON'
            else :
                status = 'OFF'
        else :
            freq = 543.210
            power = +7.77
            status = 'ON'
        client.send('%10.6f,%5.2f,%s' % (freq, power, status))

    def set_cal ( self, args, client ) :
        if len(args) != 3 :
            self.send_error('set_cal needs 3 arguments, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        power = sg.atof(args[1])
        status = args[2]
        if not SIMULATE :
            self.cal.set_frequency(freq)
            self.cal.set_output_power(power)
            if status == 'ON' :
                self.cal.enable_rf_output()
            else :
                self.cal.disable_rf_output()
        else :
            print 'cal.set_frequency(%7.4f)' % freq
            print 'cal.set_output_power(%+4.2f)' % power
            if status == 'ON' :
                print 'cal.enable_rf_output()'
            else :
                print 'cal.disable_rf_output()'
        self.send_ok(client)

    def set_cal_freq ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_cal_freq needs 1 argument, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        if not SIMULATE :
            self.cal.set_frequency(freq)
        else :
            print 'cal.set_frequency(%7.4f)' % freq
        self.send_ok(client)

    def set_cal_power ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_cal_power needs 1 argument, %d given' \
                                % len(args), client)
            return
        power = sg.atof(args[0])
        if not SIMULATE :
            self.cal.set_output_power(power)
        else :
            print 'cal.set_output_power(%+4.2f)' % power
        self.send_ok(client)

    def set_cal_status ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_cal_status needs 1 argument, %d given' \
                                % len(args), client)
            return
        status = args[0].strip()
        if not SIMULATE :
            if status == 'ON' :
                self.cal.enable_rf_output()
            else :
                self.cal.disable_rf_output()
        else :
            if status == 'ON' :
                print 'cal.enable_rf_output()'
            else :
                print 'cal.disable_rf_output()'
        self.send_ok(client)

    def get_tone_burst ( self, client ) :
        if not SIMULATE :
#            print '+++', self.tone_burst.get_frequency()
#            print self.tone_burst.get_voltage()
#            print self.tone_burst.get_voltage_offset()
#            print self.tone_burst.get_burst_cycles()
#            print self.tone_burst.get_burst_state()
            freq = sg.atof(self.tone_burst.get_frequency()) * 1e-6
            voltage = sg.atof(self.tone_burst.get_voltage())
            offset = sg.atof(self.tone_burst.get_voltage_offset())
            cycles = sg.atof(self.tone_burst.get_burst_cycles())
            if self.tone_burst.get_burst_state() == '1' :
                status = 'ON'
            else :
                status = 'OFF'
        else :
            freq = 0.200
            voltage = 0.1
            offset = 0.0
            cycles = 30.0
            status = 'ON'
        client.send('%10.6f,%4.3f,%4.3f,%4.3f,%s' % \
                        (freq, voltage, offset, cycles, status))

    def set_tone_burst ( self, args, client ) :
        if len(args) != 5 :
            self.send_error('set_tone_burst needs 5 arguments, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0]) * 1e6
        voltage = sg.atof(args[1])
        offset = sg.atof(args[2])
        cycles = sg.atoi(args[3])
        status = args[4]
        if not SIMULATE :
            self.tone_burst.set_frequency(freq)
            self.tone_burst.set_voltage(voltage)
            self.tone_burst.set_voltage_offset(offset)
            self.tone_burst.set_burst_cycles(cycles)
            if status == 'ON' :
                self.tone_burst.enable_rf_output()
            else :
                self.tone_burst.disable_rf_output()
        else :
            print 'tone_burst.set_frequency(%7.4f)' % freq
            print 'tone_burst.set_output_power(%+4.2f)' % power
            print 'tone_burst.set_offset(%4.3f)' % offset
            print 'tone_burst.set_burst_cycles(%d)' % cycles
            if status == 'ON' :
                print 'tone_burst.enable_rf_output()'
            else :
                print 'tone_burst.disable_rf_output()'
        self.send_ok(client)

    def set_tone_burst_freq ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_tone_burst_freq needs 1 argument, %d given' \
                                % len(args), client)
            return
        freq = sg.atof(args[0])
        if not SIMULATE :
            self.tone_burst.set_frequency(freq)
        else :
            print 'tone_burst.set_frequency(%7.4f)' % freq
        self.send_ok(client)

    def set_tone_burst_voltage ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_tone_burst_voltage needs 1 argument, %d given' \
                                % len(args), client)
            return
        voltage = sg.atof(args[0])
        if not SIMULATE :
            self.tone_burst.set_voltage(voltage)
        else :
            print 'tone_burst.set_output_voltage(%5.4f)' % voltage
        self.send_ok(client)

    def set_tone_burst_offset ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_tone_burst_offset needs 1 argument, %d given' \
                                % len(args), client)
            return
        offset = sg.atof(args[0])
        if not SIMULATE :
            self.tone_burst.set_voltage_offset(offset)
        else :
            print 'tone_burst.set_voltage_offset(%5.4f)' % offset
        self.send_ok(client)

    def set_tone_burst_cycles ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_tone_burst_cycles needs 1 argument, %d given' \
                                % len(args), client)
            return
        cycles = sg.atof(args[0])
        if not SIMULATE :
            self.tone_burst.set_burst_cycles(cycles)
        else :
            print 'tone_burst.set_output_cycles(%d4.3f)' % cycles
        self.send_ok(client)

    def set_tone_burst_status ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_tone_burst_status needs 1 argument, %d given' \
                                % len(args), client)
            return
        status = args[0].strip()
        if not SIMULATE :
            self.tone_burst.set_burst_state(status)
        else :
            print 'tone_burst.set_burst_state(%s)' % status
        self.send_ok(client)

    def get_switch ( self, client ) :
        if not SIMULATE :
            status = self.tone_burst.get_status().upper()
        else :
            status = 'ON'
        client.send('%s' % (status))

    def set_switch ( self, args, client ) :
        if len(args) != 1 :
            self.send_error('set_switch needs 1 argument, %d given' % \
                                len(args), client)
            return
        status = args[0]
        if not SIMULATE :
            if status == 'ON' :
                self.switch.enable_rf_output()
            else :
                self.switch.disable_rf_output()
        else :
            if status == 'ON' :
                print 'switch.enable_rf_output()'
            else :
                print 'switch.disable_rf_output()'
        self.send_ok(client)

    def send_error ( self, message, client ) :
        client.send('error: %s' % message)

    def send_ok ( self, client ) :
        client.send('OK')

    def buffer_manager ( self, buffer, msg ) :
        commands = []
        buffer += msg
        delim_pos = buffer.find(')')
        while delim_pos >= 0 :
            commands.append(buffer[:(delim_pos + 1)])
            if len(buffer) == (delim_pos + 1) :
                buffer = ''
                delim_pos = -1
            else :
                buffer = buffer[(delim_pos + 1):]
                delim_pos = buffer.find(')')
        return buffer, commands

g = GPIBserver()