#!/usr/bin/env python

import string as sg
import os
#import time

import socket
import wx

#HOST = 'polaris.cv.nrao.edu'
LOCAL_HOST = socket.gethostname()
GPIB_HOST = socket.gethostname()
print 'local host name: %s' % LOCAL_HOST
print 'gpib host name: %s' % GPIB_HOST
LOCAL_PORT = 50007
GPIB_PORT = 50006

class GPIBframe ( wx.Frame ) :
    def __init__ ( self ) :
        title = 'GPIB Instruments'
        if os.name == 'posix' :
            wx.Frame.__init__(self, None, -1, title, size=(520,330))
        else :
            wx.Frame.__init__(self, None, -1, title, size=(538,367))
        panel = wx.Panel(self, -1)
        if os.name == 'posix' :
            self.err_panel = GPIBErrorPanel(panel, 10, 230, 500, 70)
            self.lo1_panel = LO1Panel(panel, 10, 10, 110, 130, self.err_panel)
            self.lo2_panel = LO2Panel(panel, 10, 120, 110, 130, self.err_panel)
            self.sample_clk_panel = SampleClockPanel(panel, 180, 10, 100, 130,
                                                     self.err_panel)
#            self.cal_panel = CalSignalPanel(panel, 180, 120, 100, 130,
#                                            self.err_panel)
            self.tone_burst_panel = ToneBurstPanel(panel, 350, 10, 200, 150,
                                                   self.err_panel)
#            self.switch_panel = SwitchPanel(panel, 350, 170, 100, 150,
#                                            self.err_panel)
        else :
            self.err_panel = GPIBErrorPanel(panel, 10, 230, 500, 70)
            self.lo1_panel = LO1Panel(panel, 10, 10, 100, 150, self.err_panel)
            self.lo2_panel = LO2Panel(panel, 180, 10, 100, 150, self.err_panel)
            self.sample_clk_panel = SampleClockPanel(panel, 180, 125, 100, 130,
                                                     self.err_panel)
#            self.cal_panel = CalSignalPanel(panel, 180, 120, 100, 130,
#                                            self.err_panel)
            self.tone_burst_panel = ToneBurstPanel(panel, 350, 10, 100, 150,
                                                   self.err_panel)
#            self.switch_panel = SwitchPanel(panel, 350, 170, 100, 150,
#                                            self.err_panel)

#        self.skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#        socket.setdefaulttimeout(1.0)
#        self.skt.connect((LOCAL_HOST, LOCAL_PORT))
#        self.skt.settimeout(0.1)
#        self.buffer = ''
#        self.send_message('client(gpib)')

#        self.Bind(wx.EVT_TIMER, self.OnTimeOut)
        self.timer = wx.Timer(self)
        self.timer_incr = 500
        self.timer.Start(self.timer_incr)

        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)

    def OnTimeOut ( self, event ) :
        try:
            message = self.skt.recv(1024)
        except socket.timeout:
            pass
        else :
            self.parse_skt_msg(message)

    def send_message ( self, message ) :
        try :
            self.skt.send(message)
        except :
            pass

    def parse_skt_msg ( self, message ) :
        self.buffer, command = self.buffer_manager(self.buffer, message)
        if len(command) == 0 :
            return
        for cmd in command :
            words = cmd.split('(')
            cmd_name = words[0].strip()
            args = words[1].split(')')[0].strip().split(',')
            if cmd_name == 'set_lo1' :
                self.lo1_panel.set_lo1(args)
            elif cmd_name == 'set_lo2' :
                self.lo2_panel.set_lo2(args)
            elif cmd_name == 'set_sample_clk' :
                self.sample_clk_panel.set_sample_clk(args)
            elif cmd_name == 'set_tone_burst' :
                self.tone_burst_panel.set_tone_burst(args)
            elif cmd_name == 'set_cal' :
                self.cal_panel.set_cal(args)
            elif cmd_name == 'set_switch' :
                self.switch_panel.set_switch(args)
            else :
                self.err_panel.show_error('unrecognised command: %s' % cmd)

    def buffer_manager ( self, buffer, msg ) :
        command = []
        buffer += msg
        delim_pos = buffer.find(')')
        while delim_pos >= 0 :
            command.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, command

    def OnCloseWindow(self, event):
        self.send_message('closing_skt(gpib)')
        try :
            self.skt.shutdown(socket.SHUT_RDWR)
            self.skt.close()
        except :
            pass
        self.Destroy()

class LO1Panel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel
        self.if1_freq = 398.8125

        lbl = wx.StaticText(panel, -1, 'L.O. 1', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.freq, self.pwr, self.status = self.get_lo1_param()
        self.sky_freq = self.freq - self.if1_freq
        sky_freq_lbl = wx.StaticText(panel, -1, 'SkyFrq',
                                     pos=(x0 + 5, y0 + 21))
        sky_freq_lbl.SetFont(font10)
        self.sky_freq_val = wx.TextCtrl(panel, -1, '%7.3f' % self.sky_freq ,
                                        pos=(x0 + 50, y0 + 20), size=(70,22),
                                        style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.sky_freq_val.SetFont(font10)
        sky_freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 23))
        sky_freq_unit.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnSkyFreq, self.sky_freq_val)

        freq_lbl = wx.StaticText(panel, -1, 'Freq', pos=(x0 + 5, y0 + 48))
        freq_lbl.SetFont(font10)
        freq_lbl.SetFont(font10)
        self.freq_val = wx.StaticText(panel, -1, '%8.4f' % self.freq,
                                      pos=(x0 + 50, y0 + 48))
#        self.freq_val = wx.TextCtrl(panel, -1, '%7.3f' % self.freq,
#                                   pos=(x0 + 50, y0 + 45), size=(70,22),
#                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.freq_val.SetFont(font10)
        freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 48))
        freq_unit.SetFont(font10)
#        panel.Bind(wx.EVT_TEXT, self.OnFreq, self.freq_val)

        pwr_lbl = wx.StaticText(panel, -1, 'Power', pos=(x0 + 5, y0 + 73))
        pwr_lbl.SetFont(font10)
        self.pwr_val = wx.TextCtrl(panel, -1, '%+3.1f' % self.pwr,
                                   pos=(x0 + 50, y0 + 70), size=(52,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.pwr_val.SetFont(font10)
        pwr_unit = wx.StaticText(panel, -1, 'dBm', pos=(x0 + 106, y0 + 73))
        pwr_unit.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnPower, self.pwr_val)

        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 100))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 97), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnSkyFreq ( self, event ) :
        try :
            self.sky_freq = sg.atof(self.sky_freq_val.GetValue())
        except :
            pass
        else :
            self.freq = self.sky_freq + self.if1_freq
            self.send_gpib('set_lo1_freq(%8.4f)' % self.freq)
            self.freq_val.SetLabel('%8.4f' % self.freq)

#    def OnFreq ( self, event ) :
#        try :
#            self.freq = sg.atof(self.freq_val.GetValue())
#        except :
#            pass
#        else :
#            self.send_gpib('set_lo1_freq(%6.3f)' % self.freq)
#            self.sky_freq = self.freq - self.if1_freq
#            self.sky_freq_val.SetValue('%7.3f' % self.sky_freq)

    def OnPower ( self, event ) :
        try :
            self.pwr = sg.atof(self.pwr_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_lo1_power(%6.3f)' % self.pwr)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_lo1_status(%s)' % self.status)

    def set_lo1 ( self, args ) :
        if len(args) != 3 :
            print 'set_lo1 expects 3 arguments, %d given' % len(args)
            return
        self.set_freq(sg.atof(args[0]))
        self.set_power(sg.atof(args[1]))
        self.set_status(args[2].upper())

    def set_freq ( self, freq ) :
        self.freq_val.SetValue('%7.3f' % freq)
        self.freq = freq

    def set_power ( self, pwr ) :
        self.pwr_val.SetValue('%+4.1f' % pwr)
        self.pwr = pwr

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_lo1_status(%s)' % self.status)

    def get_lo1_param ( self ) :
        reply = self.get_gpib('get_lo1()')
        args = reply.split(',')
        return sg.atof(args[0]), sg.atof(args[1]), args[2].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class LO2Panel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel

        lbl = wx.StaticText(panel, -1, 'L.O. 2', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.freq, self.pwr, self.status = self.get_lo2_param()
        freq_lbl = wx.StaticText(panel, -1, 'Freq.', pos=(x0 + 5, y0 + 21))
        freq_lbl.SetFont(font10)
        self.freq_val = wx.TextCtrl(panel, -1, '%7.3f' % self.freq,
                                   pos=(x0 + 50, y0 + 20), size=(70,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.freq_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnFreq, self.freq_val)
        freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 23))
        freq_unit.SetFont(font10)

        pwr_lbl = wx.StaticText(panel, -1, 'Power', pos=(x0 + 5, y0 + 48))
        pwr_lbl.SetFont(font10)
        self.pwr_val = wx.TextCtrl(panel, -1, '%+4.2f' % self.pwr,
                                   pos=(x0 + 50, y0 + 45), size=(52,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.pwr_val.SetFont(font10)
        pwr_unit = wx.StaticText(panel, -1, 'dBm', pos=(x0 + 106, y0 + 48))
        pwr_unit.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnPower, self.pwr_val)

        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 75))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 72), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnFreq ( self, event ) :
        try :
            self.freq = sg.atof(self.freq_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_lo2_freq(%6.3f)' % self.freq)

    def OnPower ( self, event ) :
        try :
            self.pwr = sg.atof(self.pwr_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_lo2_power(%6.3f)' % self.pwr)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_lo2_status(%s)' % self.status)

    def set_lo2 ( self, args ) :
        if len(args) != 3 :
            print 'set_lo1 expects 3 arguments, %d given' % len(args)
            return
        self.set_freq(sg.atof(args[0]))
        self.set_power(sg.atof(args[1]))
        self.set_status(args[2].upper())

    def set_freq ( self, freq ) :
        self.freq_val.SetValue('%7.3f' % freq)
        self.freq = freq

    def set_power ( self, pwr ) :
        self.pwr_val.SetValue('%+4.1f' % pwr)
        self.pwr = pwr

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_lo2_status(%s)' % self.status)

    def get_lo2_param ( self ) :
        reply = self.get_gpib('get_lo2()')
        args = reply.split(',')
        return sg.atof(args[0]), sg.atof(args[1]), args[2].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class SampleClockPanel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel

        lbl = wx.StaticText(panel, -1, 'Sample Clock', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.freq, self.pwr, self.status = self.get_sample_clk_param()
        freq_lbl = wx.StaticText(panel, -1, 'Freq.', pos=(x0 + 5, y0 + 22))
        freq_lbl.SetFont(font10)
        self.freq_val = wx.TextCtrl(panel, -1, '%7.3f' % self.freq,
                                   pos=(x0 + 50, y0 + 20), size=(70,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.freq_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnFreq, self.freq_val)
        freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 22))
        freq_unit.SetFont(font10)

        pwr_lbl = wx.StaticText(panel, -1, 'Power', pos=(x0 + 5, y0 + 48))
        pwr_lbl.SetFont(font10)
        self.pwr_val = wx.TextCtrl(panel, -1, '%+4.2f' % self.pwr,
                                   pos=(x0 + 50, y0 + 45), size=(52,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.pwr_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnPower, self.pwr_val)
        pwr_unit = wx.StaticText(panel, -1, 'dBm', pos=(x0 + 106, y0 + 48))
        pwr_unit.SetFont(font10)

        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 75))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 72), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnFreq ( self, event ) :
        try :
            self.freq = sg.atof(self.freq_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_sample_clk_freq(%6.3f)' % self.freq)

    def OnPower ( self, event ) :
        try :
            self.pwr = sg.atof(self.pwr_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_sample_clk_power(%6.3f)' % self.pwr)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_sample_clk_status(%s)' % self.status)

    def set_sample_clk ( self, args ) :
        if len(args) != 3 :
            print 'set_sample_clk expects 3 arguments, %d given' % len(args)
            return
        self.set_freq(sg.atof(args[0]))
        self.set_power(sg.atof(args[1]))
        self.set_status(args[2].upper())

    def set_freq ( self, freq ) :
        self.freq_val.SetValue('%7.3f' % freq)
        self.freq = freq

    def set_power ( self, pwr ) :
        self.pwr_val.SetValue('%+4.1f' % pwr)
        self.pwr = pwr

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_sample_clk_status(%s)' % self.status)

    def get_sample_clk_param ( self ) :
        reply = self.get_gpib('get_sample_clk()')
        args = reply.split(',')
        return sg.atof(args[0]), sg.atof(args[1]), args[2].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class CalSignalPanel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel

        lbl = wx.StaticText(panel, -1, 'Cal Signal', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.freq, self.pwr, self.status = self.get_cal_param()
        freq_lbl = wx.StaticText(panel, -1, 'Freq.', pos=(x0 + 5, y0 + 22))
        freq_lbl.SetFont(font10)
        self.freq_val = wx.TextCtrl(panel, -1, '%7.3f' % self.freq,
                                   pos=(x0 + 50, y0 + 20), size=(70,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.freq_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnFreq, self.freq_val)
        freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 22))
        freq_unit.SetFont(font10)

        pwr_lbl = wx.StaticText(panel, -1, 'Power', pos=(x0 + 5, y0 + 48))
        pwr_lbl.SetFont(font10)
        self.pwr_val = wx.TextCtrl(panel, -1, '%+4.2f' % self.pwr,
                                   pos=(x0 + 50, y0 + 45), size=(52,22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.pwr_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnPower, self.pwr_val)
        pwr_unit = wx.StaticText(panel, -1, 'dBm', pos=(x0 + 106, y0 + 48))
        pwr_unit.SetFont(font10)

        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 75))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 72), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnFreq ( self, event ) :
        try :
            self.freq = sg.atof(self.freq_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_cal_freq(%6.3f)' % self.freq)

    def OnPower ( self, event ) :
        pwr = self.pwr_val.GetValue()
        if len(pwr) :
            self.pwr = sg.atof(pwr)
        else :
            self.pwr = 0.0
        self.send_gpib('set_cal_power(%6.3f)' % self.pwr)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_cal_status(%s)' % self.status)

    def set_cal ( self, args ) :
        if len(args) != 3 :
            print 'set_cal expects 3 arguments, %d given' % len(args)
            return
        self.set_freq(sg.atof(args[0]))
        self.set_power(sg.atof(args[1]))
        self.set_status(args[2].upper())

    def set_freq ( self, freq ) :
        self.freq_val.SetValue('%7.3f' % freq)
        self.freq = freq

    def set_power ( self, pwr ) :
        self.pwr_val.SetValue('%+4.1f' % pwr)
        self.pwr = pwr

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_cal_status(%s)' % self.status)

    def get_cal_param ( self ) :
        reply = self.get_gpib('get_cal()')
        args = reply.split(',')
        return sg.atof(args[0]), sg.atof(args[1]), args[2].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class ToneBurstPanel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) : 
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel

        lbl = wx.StaticText(panel, -1, 'Tone Burst', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.freq, self.voltage, self.offset, self.cycles, self.status = \
                                                  self.get_tone_burst_param()
        freq_lbl = wx.StaticText(panel, -1, 'Freq.', pos=(x0 + 5, y0 + 22))
        freq_lbl.SetFont(font10)
        self.freq_val = wx.TextCtrl(panel, -1, '%7.6f' % self.freq,
                                   pos=(x0 + 50, y0 + 20), size=(70, 22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.freq_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnFreq, self.freq_val)
        freq_unit = wx.StaticText(panel, -1, 'MHz', pos=(x0 + 125, y0 + 22))
        freq_unit.SetFont(font10)

        voltage_lbl = wx.StaticText(panel, -1, 'Ampl.', pos=(x0 + 5, y0 + 48))
        voltage_lbl.SetFont(font10)
        self.voltage_val = wx.TextCtrl(panel, -1, '%4.3f' % self.voltage,
                                   pos=(x0 + 50, y0 + 46), size=(50, 22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.voltage_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnVoltage, self.voltage_val)
        self.voltage_unit = wx.StaticText(panel, -1, 'VPP',
                                       pos=(x0 + 107, y0 + 48))
        self.voltage_unit.SetFont(font10)

        offset_lbl = wx.StaticText(panel, -1, 'Offset', pos=(x0 + 5, y0 + 74))
        offset_lbl.SetFont(font10)
        self.offset_val = wx.TextCtrl(panel, -1, '%4.3f' % self.offset,
                                   pos=(x0 + 50, y0 + 72), size=(50, 22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.offset_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnOffset, self.offset_val)
        offset_unit = wx.StaticText(panel, -1, 'V', pos=(x0 + 110, y0 + 74))
        offset_unit.SetFont(font10)

        cycles_lbl = wx.StaticText(panel, -1, 'Cycles.', pos=(x0 + 5, y0 + 98))
        cycles_lbl.SetFont(font10)
        self.cycles_val = wx.TextCtrl(panel, -1, '%d' % self.cycles,
                                   pos=(x0 + 50, y0 + 96), size=(50, 22),
                                   style=wx.TE_PROCESS_ENTER | wx.TE_LEFT)
        self.cycles_val.SetFont(font10)
        panel.Bind(wx.EVT_TEXT, self.OnCycles, self.cycles_val)

        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 125))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 121), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnFreq ( self, event ) :
        try :
            self.freq = sg.atof(self.freq_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_tone_burst_freq(%6.3f)' % self.freq)

    def OnVoltage ( self, event ) :
        try :
            self.voltage = sg.atof(self.voltage_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_tone_burst_voltage(%6.3f)' % self.voltage)

    def OnOffset ( self, event ) :
        try :
            self.offset = sg.atof(self.offset_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_tone_burst_offset(%6.3f)' % self.offset)

    def OnCycles ( self, event ) :
        try :
            self.cycles = sg.atof(self.cycles_val.GetValue())
        except :
            pass
        else :
            self.send_gpib('set_tone_burst_cycles(%6.3f)' % self.cycles)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_tone_burst_status(%s)' % self.status)

    def set_tone_burst ( self, args ) :
        if len(args) != 5 :
            print 'set_tone_burst expects 5 arguments, %d given' % len(args)
            return
        self.set_freq(sg.atof(args[0]))
        self.set_voltage(sg.atof(args[1]))
        self.set_offset(sg.atof(args[2]))
        self.set_cycles(sg.atoi(args[3]))
        self.set_status(args[3].upper())

    def set_freq ( self, freq ) :
        self.freq_val.SetValue('%7.6f' % freq)
        self.freq = freq

    def set_voltage ( self, voltage ) :
        self.voltage_val.SetValue('%4.3f' % voltage)
        self.voltage = voltage

    def set_offset ( self, offset ) :
        self.offset_val.SetValue('%4.3f' % offset)
        self.offset = offset

    def set_cycles ( self, cycles ) :
        self.cycles_val.SetValue('%d' % cycles)
        self.cycles = cycles

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_tone_burst_status(%s)' % self.status)

    def get_tone_burst_param ( self ) :
        reply = self.get_gpib('get_tone_burst()')
        args = reply.split(',')
        return sg.atof(args[0]), sg.atof(args[1]), sg.atof(args[2]), \
            sg.atof(args[3]), args[4].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class SwitchPanel :
    def __init__ ( self, panel, x0, y0, xsize, ysize, err_panel ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font8 = wx.Font(8, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        self.err_panel = err_panel

        lbl = wx.StaticText(panel, -1, 'Switch', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        self.status = self.get_switch_param()
        stat_lbl = wx.StaticText(panel, -1, 'Status', pos=(x0 + 5, y0 + 27))
        stat_lbl.SetFont(font10)
        self.stat_val= wx.Button(panel, -1, self.status,
                                     pos=(x0 + 50, y0 + 24), size=(40,25))
        panel.Bind(wx.EVT_BUTTON, self.OnStatus, self.stat_val)
        self.stat_val.SetFont(font8)

    def OnStatus ( self, event ) :
        old_stat = self.stat_val.GetLabel()
        if old_stat == 'OFF' :
            self.status = 'ON'
        else :
            self.status = 'OFF'
        self.stat_val.SetLabel(self.status)
        self.send_gpib('set_switch_status(%s)' % self.status)

    def set_status ( self, status ) :
        self.stat_val.SetLabel(status)
        self.status = status
        self.send_gpib('set_switch_status(%s)' % self.status)

    def set_switch ( self, args ) :
        self.set_status(args[0].upper())

    def get_switch_param ( self ) :
        reply = self.get_gpib('get_switch()')
        args = reply.split(',')
        return args[0].strip().upper()

    def send_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        if ret_msg != 'OK' :
            self.err_panel.show_error(ret_msg)
        skt.close()

    def get_gpib ( self, msg ) :
        skt = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        skt.connect((GPIB_HOST, GPIB_PORT))
        skt.send(msg)
        ret_msg = skt.recv(1024)
        skt.close()
        return ret_msg

class GPIBErrorPanel :
    def __init__ ( self, panel, x0, y0, xsize, ysize ) :
        font11 = wx.Font(11, wx.NORMAL, wx.NORMAL, wx.NORMAL)
        font10 = wx.Font(10, wx.NORMAL, wx.NORMAL, wx.NORMAL)

        lbl = wx.StaticText(panel, -1, 'Error Messages', pos=(x0 + 5, y0))
        lbl.SetFont(font11)

        simple_list = ['']
        self.err_box = wx.ListBox(panel, -1, (x0, y0 + 20), (xsize, ysize),
                                  simple_list, wx.LB_NEEDED_SB | wx.LB_HSCROLL)
        
        self.err_box.SetFont(font10)
        self.err_box.Clear()
        self.msg_ctr = 0

    def show_error ( self, err_msg ) :
        self.err_box.InsertItems([err_msg], self.msg_ctr)
        self.err_box.SetSelection(self.msg_ctr)
        self.msg_ctr += 1

    def clear_errors ( self ) :
        self.err_box.Clear()
        self.msg_ctr = 0


if __name__ == '__main__' :
    app = wx.PySimpleApp()
    frame = GPIBframe()
    frame.Show()
    app.MainLoop()