From fbb52cfd6d55ce2c2ffaec73b2633b1c2cad51f2 Mon Sep 17 00:00:00 2001 From: dttsp <dttsp> Date: Sun, 12 Jun 2005 13:47:05 +0000 Subject: [PATCH] New hardware control code --- pyhw2/Makefile | 13 + pyhw2/README | 37 + pyhw2/demo.c | 44 + pyhw2/hardware.c | 1011 +++++++++++ pyhw2/hardware.i | 5 + pyhw2/hardware_wrap.c | 3927 +++++++++++++++++++++++++++++++++++++++++ pyhw2/hw2.py | 39 + pyhw2/sdr1k-setup.py | 23 + pyhw2/sdr1khw.py | 330 ++++ 9 files changed, 5429 insertions(+) create mode 100644 pyhw2/Makefile create mode 100644 pyhw2/README create mode 100644 pyhw2/demo.c create mode 100644 pyhw2/hardware.c create mode 100644 pyhw2/hardware.i create mode 100644 pyhw2/hardware_wrap.c create mode 100644 pyhw2/hw2.py create mode 100644 pyhw2/sdr1k-setup.py create mode 100644 pyhw2/sdr1khw.py diff --git a/pyhw2/Makefile b/pyhw2/Makefile new file mode 100644 index 0000000..f8e1fc7 --- /dev/null +++ b/pyhw2/Makefile @@ -0,0 +1,13 @@ +CFLAGS = -g -I. -I/usr/local/include +LDFLAGS = +LIBS = -lm + + +python: + swig -python hardware.i + gcc -fPIC -I. -O3 -I/usr/include/python -c hardware_wrap.c + gcc -fPIC -I. -O3 -c hardware.c + ld -shared hardware.o hardware_wrap.o -o _sdr1khw.so + +demo: demo.o hardware.o + $(CC) $(LDFLAGS) -o demo demo.o hardware.o $(LIBS) diff --git a/pyhw2/README b/pyhw2/README new file mode 100644 index 0000000..28307a7 --- /dev/null +++ b/pyhw2/README @@ -0,0 +1,37 @@ +======================================================================== +Simple stuff. + +To use, run python interactively. Then + +>>> execfile("sdr1k-setup.py") + +to get the interface started. + +To set the frequency, do + +>>> setDDSFreq(14.077) + +To toggle the mute relay, + +>>> setMuteRelay(not getMuteRelay()) + +etc. + +To shut down, + +>>> closeRig() + +and exit python. (The startup script, which is crude and will be +replaced shortly, does an openRig("/dev/parport0") +======================================================================== + +To build: + +There is a simple Makefile that does just the following -- + +swig -python hardware.i +gcc -fPIC -I. -I/usr/include/python -c hardware_wrap.c +gcc -fPIC -I. -c hardware.c +ld -shared hardware.o hardware_wrap.o -o _sdr1khw.so + +Ready to go. diff --git a/pyhw2/demo.c b/pyhw2/demo.c new file mode 100644 index 0000000..873e4a8 --- /dev/null +++ b/pyhw2/demo.c @@ -0,0 +1,44 @@ +// demo.c + +#include <hardware.h> + +#define FALSE 0 +#define TRUE 1 + +int +main(int argc, char **argv) { +#if 0 + if (!openPort("/dev/parport0")) + perror("/dev/parport0"), exit(1); +#endif + if (!openPort("/dev/null")) + perror("/dev/null"), exit(1); + + setRFE_Enabled(TRUE); + ResetRFE(); + setXVTR_Enabled(FALSE); + setExtended(FALSE); + setXVTR_TR_Relay(FALSE); + setBandRelay(bs0); + Init(); + setVFOOffset(0.0); + setATTN_Relay(TRUE); + setTransmitRelay(FALSE); + setGainRelay(TRUE); + setSpurReduction(FALSE); + setExternalOutput(FALSE); + setDDSClockCorrection(0.0); + setDDSFreq(13.845); + setMuteRelay(FALSE); + + fprintf(stderr, "Ready\n"); + { + int i; + for (i = 0; i < 100; i++) + setDDSFreq(14.060); + } + fprintf(stderr, "Done\n"); + + closePort(); + exit(0); +} diff --git a/pyhw2/hardware.c b/pyhw2/hardware.c new file mode 100644 index 0000000..0cdfca9 --- /dev/null +++ b/pyhw2/hardware.c @@ -0,0 +1,1011 @@ +// hardware.c +// version 2 + +#include <hardware.h> + +// Register memory for IC11 +int ic11_memory; + +// Register memory for IC7 +int ic7_memory; + +BOOL rfe_enabled; // True if RFE board is enabled +BOOL xvtr_enabled; // Transverter is enabled +BOOL pa_enabled; // Transverter is enabled + +// Latch Memories +BandSetting band_relay = bs0; +int external_output = 0; +int mute_relay = 0; +int transmit_relay = 0; +int gain_relay = 0; +int latch_delay = 0; // measured in 100ns steps (10 = 1us) + +// DDS Clock properties +double dds_clock = 0.0; // DDS Clock oscillator in MHz +int pll_mult = 0; // DDS PLL multiplier +double dds_clock_correction = 0.0; // Oscillator dds_clock_correction in MHz +double sysClock = 0.0; // DDS Internal System Clock in MHz +int ioud_clock = 0; // IO Update clock period +ushort dac_mult = 0; // DAC Multiplier setting + +// DDS Frequency Control properties +double dds_freq = 0.0; // Last VFO Setting in MHz +double if_freq = 0.0; // IF Frequency Offset in MHz +BOOL if_shift = FALSE;// Turns Offset Baseband IF Shift On +BOOL spur_reduction = FALSE;// Eliminates Phase Truncation Spurs +double dds_step_size = 0.0; // DDS Step in MHz for spur removal +int sample_rate = 0; // ADC Sampling Rate in Hz +int fft_length = 0; // Length of FFT in bins +double FFT_Bin_Size = 0.0; // Bandwidth of FFT bin +int tune_fft = 0; // Offset tuning of FFT bins +double tune_frac_rel = 0.0; // In relative frequency (frequency/m_Sample_Rate) +double vfo_offset = 0.0; +//double last_VFO = 0.0; // temp store for last VFO frequency + +double min_freq = 0.012; // minimum allowable tuning frequency +double max_freq = 65.0; // maximum allowable tuning frequency + +// PIO register base address +u_short baseAdr = 0x378; + +// Current Bandplan +BandPlan curBandPlan = IARU1; + +double TWO_TO_THE_48_DIVIDED_BY_200 = 1407374883553.28; +long last_tuning_word = 0; +// private Mutex parallel_mutex = new Mutex(); +// private Mutex dataline_mutex = new Mutex(); + +BOOL usb_enabled = FALSE; + +//------------------------------------------------------------------------ + +PRIVATE int parportfd = -1; + +PUBLIC BOOL openPort(char *port) { + int mode = IEEE1284_MODE_COMPAT; + if (!port) port = "/dev/parport0"; + if ((parportfd = open(port, O_RDWR)) < 0) { + perror("open parallel port"); + return FALSE; + } + ioctl(parportfd, PPCLAIM); + ioctl(parportfd, PPSETMODE, &mode); + return TRUE; +} + +PUBLIC void closePort(void) { + ioctl(parportfd, PPRELEASE); + close(parportfd); +} + +double DttSP_SampleRate = 48000.0; + +PUBLIC void USB_Sdr1kLatch(int l, BYTE b) {} +PUBLIC BYTE USB_Sdr1kGetStatusPort(void) { return 0; } +PUBLIC int USB_Sdr1kGetADC(void) { return 0; } +PUBLIC void USB_Sdr1kDDSReset(void) {} +PUBLIC void USB_Sdr1kDDSWrite(BYTE addr, BYTE data) {} +PUBLIC void USB_Sdr1kSRLoad(BYTE reg, BYTE data) {} +PUBLIC void DttSP_ChangeOsc(double val) {} + +PRIVATE void Delay(void) { + usleep(1000 * latch_delay); +} + +PRIVATE void Sleep(int ms) { + usleep(1000 * ms); +} + +PRIVATE void PWrite(BYTE data) { + //Write data Byte to parallel port + ioctl(parportfd, PPWDATA, &data); + //Delay to allow data line setup + Delay(); +} + +PRIVATE void Latch(CtrlPin vCtrlPin) { + //Strobe the specified pin to latch data + unsigned char mask; + switch (vCtrlPin) { + case EXT: + mask = 0xA, ioctl(parportfd, PPWCONTROL, &mask); + Delay(); + mask = 0xB, ioctl(parportfd, PPWCONTROL, &mask); + break; + case BPF: + mask = 0x9, ioctl(parportfd, PPWCONTROL, &mask); + Delay(); + mask = 0xB, ioctl(parportfd, PPWCONTROL, &mask); + break; + case DAT: + mask = 0xF, ioctl(parportfd, PPWCONTROL, &mask); + Delay(); + mask = 0xB, ioctl(parportfd, PPWCONTROL, &mask); + break; + case ADR: + mask = 0x3, ioctl(parportfd, PPWCONTROL, &mask); + Delay(); + mask = 0xB, ioctl(parportfd, PPWCONTROL, &mask); + break; + } +} + +PRIVATE void ResetLatches(void) { + //Set all latch outputs to logic zero (relays off) + if (usb_enabled) { + gain_relay = GAIN; + external_output = 0; + USB_Sdr1kLatch(SDR1K_LATCH_EXT, (BYTE) (external_output + gain_relay)); + setBandRelay(bsnone); + transmit_relay = 0; + mute_relay = MUTE; + USB_Sdr1kLatch(SDR1K_LATCH_BPF, (BYTE) (band_relay + transmit_relay + mute_relay)); + } else { + PWrite(0); + Latch(ADR); + Latch(DAT); + gain_relay = GAIN; + external_output = 0; + PWrite((BYTE) (external_output + gain_relay)); + Latch(EXT); + setBandRelay(bsnone); + transmit_relay = 0; + mute_relay = MUTE; + PWrite((BYTE) (band_relay + transmit_relay + mute_relay)); + Latch(BPF); + } +} + +PRIVATE void DDSWrite(BYTE data, BYTE addr) { + if (usb_enabled) + USB_Sdr1kDDSWrite(addr, data); + else { + PWrite(data); + Latch(DAT); + PWrite((BYTE) (addr + WRB)); + Latch(ADR); + PWrite(addr); + Latch(ADR); + PWrite(WRB); + Latch(ADR); + } +} + +PRIVATE void ResetDDS(void) { + if(usb_enabled) + USB_Sdr1kDDSReset(); + else { + PWrite(RESET + WRB); + Latch(ADR); + PWrite(WRB); + Latch(ADR); + } + DDSWrite(COMP_PD, 29); //Power down comparator + if(pll_mult == 1) + DDSWrite(BYPASS_PLL, 30); + else + DDSWrite((BYTE) pll_mult, 30); + DDSWrite(BYPASS_SINC, 32); +} + + +PRIVATE void CalcClock(void) { + sysClock = 200.0 + dds_clock_correction; + dds_step_size = sysClock / pow(2.0, 48.0); +} + +PRIVATE void SetRadioFreq(double f) { + double vfoFreq = f; + long tuning_word; + + // calculate software frequency to program + if(xvtr_enabled && f >= 144 && f <= 146) + f -= 116; //Subtract 116MHz (144-28) from VFO display frequency + + if (if_shift) + f -= if_freq; // adjust for IF shift + + f += vfo_offset; // adjust for vfo offset + + tuning_word = (long) (f / sysClock * pow(2.0, 48.0)); + + if (spur_reduction) { + // start with current tuning word + // clear first bit, low 31 bits; set bit 31 + unsigned long long + sr_tuning_word = (tuning_word & ~(0x80007fffffffLL)) | 0x000080000000LL; + double software_offset = (sr_tuning_word - tuning_word) * dds_step_size; + + if (if_shift) //Convert the tuning fraction to rel frq + tune_frac_rel = 1000000.0 * (software_offset) - 11025.0; + else + tune_frac_rel = 1000000.0 * (software_offset); + DttSP_ChangeOsc(tune_frac_rel); + + tuning_word = sr_tuning_word; + } + + // program hardware + SetBPF(vfoFreq); + + if (tuning_word != last_tuning_word) { + int i; + last_tuning_word = tuning_word; //save new tuning word + + //parallel_mutex.WaitOne(); + for(i = 0; i < 6; i++) { + BYTE b = (BYTE) (tuning_word >> (40 - i * 8)); + DDSWrite(b, (BYTE) (4 + i)); + } + //parallel_mutex.ReleaseMutex(); + } +} + +PUBLIC BOOL IsHamBand(BandPlan b) { + if (getExtended()) return TRUE; + switch (b) { + case IARU1: + if (dds_freq >= 1.8 && dds_freq <= 2.0) return TRUE; + else if (dds_freq >= 3.5 && dds_freq <= 4.0) return TRUE; + else if (dds_freq == 5.3305) return TRUE; + else if (dds_freq == 5.3465) return TRUE; + else if (dds_freq == 5.3665) return TRUE; + else if (dds_freq == 5.3715) return TRUE; + else if (dds_freq == 5.4035) return TRUE; + else if (dds_freq >= 7.0 && dds_freq <= 7.3) return TRUE; + else if (dds_freq >= 10.1 && dds_freq <= 10.15) return TRUE; + else if (dds_freq >= 14.0 && dds_freq <= 14.35) return TRUE; + else if (dds_freq >= 18.068 && dds_freq <= 18.168) return TRUE; + else if (dds_freq >= 21.0 && dds_freq <= 21.45) return TRUE; + else if (dds_freq >= 24.89 && dds_freq <= 24.99) return TRUE; + else if (dds_freq >= 21.0 && dds_freq <= 21.45) return TRUE; + else if (dds_freq >= 28.0 && dds_freq <= 29.7) return TRUE; + else if (dds_freq >= 50.0 && dds_freq <= 54.0) return TRUE; + else if (dds_freq >= 144.0 && dds_freq <= 146.0) { + if (rfe_enabled && xvtr_enabled) return TRUE; + else return FALSE; + } else return FALSE; + default: + return FALSE; + // TODO: Implement other bandplans here + } +} + +//------------------------------------------------------------------------ +// Properties +// + +PRIVATE BOOL enable_LPF0 = FALSE; +PUBLIC BOOL getEnableLPF0 (void) { return enable_LPF0; } +PUBLIC void setEnableLPF0 (BOOL value) { enable_LPF0 = value; }; + +PRIVATE BOOL extended = FALSE; +PUBLIC BOOL getExtended (void) { return extended; } +PUBLIC void setExtended (BOOL value) { extended = value; } + +PRIVATE BOOL x2_enabled = FALSE; +PUBLIC BOOL getX2Enabled (void) { return x2_enabled; } +PUBLIC void setX2Enabled (BOOL value) { x2_enabled = value; } + +PRIVATE int x2_delay = 500; +PUBLIC int getX2Delay (void) { return x2_delay; } +PUBLIC void setX2Delay (int value) { x2_delay = value; } + +PUBLIC BOOL getRFE_Enabled (void) { return rfe_enabled; } +PUBLIC void setRFE_Enabled (BOOL value) { + rfe_enabled = value; + SetRadioFreq(dds_freq); +} + +PUBLIC BOOL getPA_Enabled (void) { return pa_enabled; } +PUBLIC void setPA_Enabled (BOOL value) { pa_enabled = value; } + +PUBLIC BOOL getXVTR_Enabled (void) { return xvtr_enabled; } +PUBLIC BOOL setXVTR_Enabled (BOOL value) { + xvtr_enabled = value; + if (xvtr_enabled) max_freq = 146.0; + else max_freq = 65.0; +} + +PUBLIC BOOL getUSB_Enabled (void) { return usb_enabled; } +PUBLIC void setUSB_Enabled (BOOL value) { usb_enabled = value; } + +PRIVATE XVTRTRMode current_xvtr_tr_mode = NEGATIVE; +PUBLIC XVTRTRMode getCurrentXVTRTRMode (void) { return current_xvtr_tr_mode; } +PUBLIC void setCurrentXVTRTRMode (XVTRTRMode value) { + current_xvtr_tr_mode = value; + switch (current_xvtr_tr_mode) { + case NEGATIVE: setXVTR_TR_Relay(TRUE); break; // Set to receive + case POSITIVE: setXVTR_TR_Relay(FALSE); break; // Set to receive + case NONE: break; + } +} + +PUBLIC int getLatchDelay (void) { return latch_delay; } +PUBLIC void setLatchDelay (int value) { latch_delay = value; } + +PUBLIC double getMinFreq (void) { return min_freq; } +PUBLIC double getMaxFreq (void) { return max_freq; } + +PUBLIC u_short getBaseAddr (void) { return baseAdr; } +PUBLIC u_short setBaseAddr (u_short value) { baseAdr = value; } + +PUBLIC BandSetting getBandRelay (void) { return band_relay; } +PUBLIC void setBandRelay (BandSetting value) { + band_relay = value; + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_BPF, + (BYTE) (band_relay + transmit_relay + mute_relay)); + else { + PWrite((BYTE) (band_relay + transmit_relay + mute_relay)); + Latch(BPF); + } +} + +PUBLIC BOOL getTransmitRelay (void) { + //Get state of TR relay on BPF board + if (transmit_relay == TR) return TRUE; + else return FALSE; +} +PUBLIC void setTransmitRelay (BOOL value) { + BYTE tmpLatch = 0; + BOOL tmpATTN = FALSE; + //If in valid Amateur BandRelay Save and output new TR Relay setting + if (value == TRUE) { + //if (IsHamBand(curBandPlan) == TRUE) + { + if (x2_enabled) { + SetExt(P7); // set X2-7 + Sleep(x2_delay); // pause for ext. relays + } + transmit_relay = TR; // Set to TX + if (rfe_enabled == TRUE) { + tmpATTN = getATTN_Relay(); + if (xvtr_enabled && dds_freq >= 144) { + switch (current_xvtr_tr_mode) { + case NEGATIVE: setXVTR_TR_Relay(FALSE); break; + case POSITIVE: setXVTR_TR_Relay(TRUE); break; + case NONE: break; + } + } else setAMP_Relay(TRUE); //Switch RFE to transmit + tmpLatch = (BYTE) (transmit_relay + mute_relay + DCDR_NE);// DCDR_NE for 2-4 Decoder to stay high + } else + tmpLatch = (BYTE) (band_relay + transmit_relay + mute_relay); + } + } else { + transmit_relay = 0; // Set to RX + if (rfe_enabled) { + setAMP_Relay(FALSE); + tmpLatch = (BYTE) (transmit_relay + mute_relay + DCDR_NE); + if (xvtr_enabled) { + switch(current_xvtr_tr_mode) { + case NEGATIVE: setXVTR_TR_Relay(TRUE); break; + case POSITIVE: setXVTR_TR_Relay(FALSE); break; + case NONE: break; + } + } + setATTN_Relay(tmpATTN); + } else + tmpLatch = (BYTE) (band_relay + transmit_relay + mute_relay); + } + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_BPF, tmpLatch); + else { + PWrite(tmpLatch); + Latch(BPF); + } + if (!value && x2_enabled) { + Sleep(x2_delay); // pause for ext. relays + ResExt(P7); // clear X2-7 + } + if (pa_enabled) { // set PA transmit/bias + if (dds_freq >= 1.8 && dds_freq <= 29.7) { + if (value) { // TX + setPA_TransmitRelay(TRUE); + setPA_BiasOn(TRUE); + } else { // RX + setPA_BiasOn(FALSE); + setPA_TransmitRelay(FALSE); + } + } + } +} + +PUBLIC BOOL getMuteRelay (void) { + // Get state of MUTE relay on TRX board + if (mute_relay == MUTE) return FALSE; + else return TRUE; +} +PUBLIC void setMuteRelay (BOOL value) { + BYTE data = 0; + // Mute the speaker relay if TRUE + if (value == TRUE) mute_relay = 0; + else mute_relay = MUTE; + if (rfe_enabled) + data = (BYTE) (transmit_relay + mute_relay + DCDR_NE); + else + data = (BYTE) (band_relay + transmit_relay + mute_relay); + if (usb_enabled) { + USB_Sdr1kLatch(SDR1K_LATCH_BPF, data); + } else { + PWrite(data); + Latch(BPF); + } +} + +PUBLIC BOOL getGainRelay (void) { + // Get state of GAIN relay on TRX board + if (gain_relay == GAIN) return FALSE; + else return TRUE; +} +PUBLIC void setGainRelay (BOOL value) { + // Save and output state of GAIN relay on TRX board + if (value == TRUE) gain_relay = 0; // 40dB or 0dB w/RFE + else gain_relay = GAIN; // 26dB + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_EXT, (BYTE) (external_output + gain_relay)); + else { + PWrite((BYTE) (external_output + gain_relay)); + Latch(EXT); + } +} + +PUBLIC int getExternalOutput (void) { return external_output; } +PUBLIC void setExternalOutput (int value) { + //Save and output state of External Control outputs on PIO board + external_output = value; + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_EXT, (BYTE) (external_output + gain_relay)); + else { + PWrite((BYTE) (external_output + gain_relay)); + Latch(EXT); + } +} + +PUBLIC double getDDSClockCorrection (void) { return dds_clock_correction; } +PUBLIC void setDDSClockCorrection (double value) { + dds_clock_correction = value; + CalcClock(); + SetRadioFreq(dds_freq); +} + +PUBLIC int getPLLMult (void) { return pll_mult; } +PUBLIC void setPLLMult (int value) { + pll_mult = value; + if (pll_mult == 1) DDSWrite(BYPASS_PLL, 30); // Bypass PLL if multiplier value is 1 + else DDSWrite((BYTE) pll_mult, 30); // Set for External Clock + CalcClock(); +} + +PUBLIC double getDDSClock (void) { return dds_clock; } +PUBLIC void setDDSClock (double value) { + //Compute internal DDS System Clock and Phase Truncation Elimination Step + dds_clock = value; + CalcClock(); +} + +PUBLIC BOOL getIFShift (void) { return if_shift; } +PUBLIC void setIFShift (BOOL value) { + // Turns IF shift on and off + if_shift = value; + if (!spur_reduction) { + if (if_shift) DttSP_ChangeOsc(-11025.0); + else DttSP_ChangeOsc(0.0); + } + SetRadioFreq(dds_freq); +} + +PUBLIC BOOL getSpurReduction (void) { return spur_reduction; } +PUBLIC BOOL setSpurReduction (BOOL value) { + // Turns DDS Phase Truncation Spur reduction on and off + spur_reduction = value; + if (!spur_reduction) { + if (if_shift) DttSP_ChangeOsc(-11025.0); + else DttSP_ChangeOsc(0.0); + } + SetRadioFreq(dds_freq); +} + +PUBLIC double getIFFreq (void) { return if_freq; } +PUBLIC void setIFFreq (double value) { if_freq = value; } + +PUBLIC double getDDSFreq (void) { return dds_freq; } +PUBLIC void setDDSFreq (double value) { + dds_freq = value; + SetRadioFreq(dds_freq); +} + +PUBLIC int getSampleRate (void) { return sample_rate; } +PUBLIC void setSampleRate (int value) { + sample_rate = value; + if (fft_length > 0) + FFT_Bin_Size = (sample_rate / fft_length) * 1e-6; +} + +PUBLIC int getFFTLength (void) { return fft_length; } +PUBLIC void setFFTLength (int value) { + fft_length = value; + //Compute bandwidth of FFT bin + if (fft_length > 0) + FFT_Bin_Size = (sample_rate / fft_length) * 1e-6; +} + +PUBLIC int getTuneFFT (void) { return tune_fft; } + +PUBLIC double getTuneFracRel (void) { return tune_frac_rel; } + +PUBLIC double getVFOOffset (void) { return vfo_offset; } +PUBLIC void setVFOOffset (double value) { + vfo_offset = value; + SetRadioFreq(dds_freq); +} + +PUBLIC int getIOUDClock (void) { return ioud_clock; } +PUBLIC void setIOUDClock (int value) { + double bitVal, bytVal; + BYTE lWord; + int i; + ioud_clock = value; //Save value + bitVal = value; //Compute Numeric Value + for (i = 24; i >= 0; i -= 8) { //Convert to binary strings + bytVal = bitVal / (01 << i); //Compute binary byte Value + lWord = (BYTE) bytVal; //Truncate fractional portion + bitVal -= lWord * (01 << i); //Reduce value + switch (i) { //Write to byte position + case 32: DDSWrite(lWord, 22); break; + case 16: DDSWrite(lWord, 23); break; + case 8: DDSWrite(lWord, 24); break; + case 0: DDSWrite(lWord, 25); break; + } + } +} + +PUBLIC u_short getDACMult (void) { return dac_mult; } +PUBLIC void setDACMult (u_short value) { + double bitVal, bytVal; + BYTE lWord; + int i; + dac_mult = value; + bitVal = value; //Compute Numeric Value + for (i = 8; i >= 0; i -= 8) { //Convert to binary strings + bytVal = bitVal / (01 << i); //Compute binary byte Value + BYTE lWord = (BYTE) bytVal; //Truncate fractional portion + bitVal -= lWord * (01 << i); //Reduce value + switch (i) { + case 8: DDSWrite(lWord, 33); break; + case 0: DDSWrite(lWord, 34); break; + } + } + //Send new I DAC Multiplier value to DDS + bitVal = value; //Compute Numeric Value + for (i = 8; i >= 0; i -= 8) { //Convert to binary strings. + bytVal = bitVal / (01 << i); //Compute binary byte Value + lWord = (BYTE) bytVal; //Truncate fractional portion + bitVal -= lWord * (01 << i); //Reduce value + switch (i) { //Write to byte position + case 8: DDSWrite(lWord, 35); break; + case 0: DDSWrite(lWord, 36); break; + } + } +} + +PUBLIC BYTE StatusPort(void) { + if (usb_enabled) + return (BYTE) USB_Sdr1kGetStatusPort(); + else { + BYTE status; + ioctl(parportfd, PPRSTATUS, (char *) &status); + return status; + } +} + +PUBLIC void Init(void) { + setIFShift(TRUE); + // user setable through the setup form + // DDSClockCorrection = 0.000; + setPLLMult(1); + setDDSClock(200); + setIFFreq(0.011025); + setSampleRate((int) DttSP_SampleRate); + setFFTLength(4096); + //setDACMult(4095); +} + +PUBLIC void PowerOn(void) { + if (rfe_enabled) { + // set mute/gain relays based on console + if (xvtr_enabled && current_xvtr_tr_mode == NEGATIVE) + setXVTR_TR_Relay(TRUE); + else + setXVTR_TR_Relay(FALSE); + //DDSFreq = dds_freq; + ic11_memory |= ADC_CS_NOT; // set CS_NOT high + ic11_memory |= ATUCTL; + ic7_memory |= PA_BIAS_NOT; + SRLoad(IC11, ic11_memory); + SRLoad(IC7, ic7_memory); + } +} + +PUBLIC void StandBy(void) { + ResetLatches(); + if (rfe_enabled) ResetRFE(); + if (xvtr_enabled) setXVTR_TR_Relay(FALSE); + // TODO: Fix bias glitch on reset w/hardware rewrite + if (rfe_enabled) { + SRLoad(IC7, PA_BIAS_NOT); + SRLoad(IC11, ADC_CS_NOT); + } + ResetDDS(); +} + +PUBLIC void SetExt(ExtPin pin) { + //Set the designated external pin high + external_output |= (BYTE) pin; + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_EXT, (BYTE) (external_output + gain_relay)); + else { + PWrite((BYTE) (external_output + gain_relay)); + Latch(EXT); + } +} + +PUBLIC void ResExt(ExtPin pin) { + //Reset the designated external pin high + external_output &= ~(BYTE) pin; + if (usb_enabled) + USB_Sdr1kLatch(SDR1K_LATCH_EXT, (BYTE) (external_output + gain_relay)); + else { + PWrite((BYTE) (external_output + gain_relay)); + Latch(EXT); + } +} + +PUBLIC BOOL PinValue(ExtPin pin) { + //Return TRUE if Pin is set + if ((external_output & (int) pin) != 0) + return TRUE; + else + return FALSE; +} + +PUBLIC void SetBPF(double vfo_value) { + if (rfe_enabled) { + if (vfo_value <= 2.5) { + if (pa_enabled) PA_SetLPF(PA_LPF_160); + if (vfo_value <= 0.3 && enable_LPF0) { + SRLoad(IC10, BPF0); + SRLoad(IC9, LPF0); + } else { + SRLoad(IC10, LPF9 + BPF0); + SRLoad(IC9, 0); + } + } else if (vfo_value <= 4) { + if (pa_enabled) PA_SetLPF(PA_LPF_80); + SRLoad(IC10, BPF1); + SRLoad(IC9, LPF7); + } else if (vfo_value <= 6) { + if (pa_enabled) PA_SetLPF(PA_LPF_60_40); + SRLoad(IC10, BPF1); + SRLoad(IC9, LPF2); + } else if (vfo_value <= 7.3) { + if (pa_enabled) PA_SetLPF(PA_LPF_60_40); + SRLoad(IC10, BPF2); + SRLoad(IC9, LPF5); + } else if (vfo_value <= 10.2) { + if (pa_enabled) PA_SetLPF(PA_LPF_30_20); + SRLoad(IC10, BPF2); + SRLoad(IC9, LPF4); + } else if (vfo_value <= 12) { + if (pa_enabled) PA_SetLPF(PA_LPF_OFF); + SRLoad(IC10, BPF2); + SRLoad(IC9, LPF3); + } else if (vfo_value <= 14.5) { + if (pa_enabled) PA_SetLPF(PA_LPF_30_20); + SRLoad(IC10, BPF3); + SRLoad(IC9, LPF3); + } else if (vfo_value <= 21.5) { + if (pa_enabled) PA_SetLPF(PA_LPF_17_15); + SRLoad(IC10, BPF3 + LPF8); + SRLoad(IC9, 0); + } else if (vfo_value <= 24) { + if (pa_enabled) PA_SetLPF(PA_LPF_12_10); + SRLoad(IC10, BPF3); + SRLoad(IC9, LPF6); + } else if (vfo_value <= 30) { + if (pa_enabled) PA_SetLPF(PA_LPF_12_10); + SRLoad(IC10, BPF4); + SRLoad(IC9, LPF6); + } else if (vfo_value <= 36) { + if (pa_enabled) PA_SetLPF(PA_LPF_OFF); + SRLoad(IC10, BPF4); + SRLoad(IC9, LPF1); + } else if (vfo_value <= 65) { + if (pa_enabled) PA_SetLPF(PA_LPF_OFF); + SRLoad(IC10, BPF5); + SRLoad(IC9, LPF1); + } else if (xvtr_enabled && vfo_value >= 144 && vfo_value <= 146) { + if (pa_enabled) PA_SetLPF(PA_LPF_OFF); + SRLoad(IC10, BPF4); + SRLoad(IC9, LPF6); + setXVTR_Relay(TRUE); + } + if (xvtr_enabled && vfo_value < 144) + setXVTR_Relay(FALSE); + } else { + if (vfo_value < 2.5) setBandRelay(bs0); + else if (vfo_value < 6) setBandRelay(bs1); + else if (vfo_value < 12) setBandRelay(bs2); + else if (vfo_value < 24) setBandRelay(bs3); + else if (vfo_value < 36) setBandRelay(bs4); + else setBandRelay(bs5); + } +} + +PUBLIC void TestPort(void) { + //Toggle 1 and 0 to each of the four parallel port latches + if (usb_enabled) { + USB_Sdr1kLatch(SDR1K_LATCH_BPF, 0); + USB_Sdr1kLatch(SDR1K_LATCH_EXT, 0); + USB_Sdr1kLatch(SDR1K_LATCH_BPF, 255); + USB_Sdr1kLatch(SDR1K_LATCH_EXT, 255); + } else { + PWrite(0); + Latch(BPF); + Latch(ADR); + Latch(DAT); + Latch(EXT); + PWrite(255); + Latch(BPF); + Latch(ADR); + Latch(DAT); + Latch(EXT); + } +} + +PUBLIC void RCKStrobe(BOOL ClearReg, RFE_RCK Reg) { + // Strobe the RFE 1:4 decoder output to transfer contents + // of shift register to output latches + BYTE data = 0; + if (ClearReg) data = (BYTE) (Reg); + else data = (BYTE) (SCLR_NOT + Reg + transmit_relay + mute_relay); + if (usb_enabled) { + USB_Sdr1kLatch(SDR1K_LATCH_BPF, data); + USB_Sdr1kLatch(SDR1K_LATCH_BPF, (BYTE) (SCLR_NOT + DCDR_NE + transmit_relay + mute_relay)); + } else { + PWrite(data); + Latch(BPF); + PWrite((BYTE) (SCLR_NOT + DCDR_NE + transmit_relay + mute_relay)); + Latch(BPF); + } +} + +PUBLIC void SRLoad(RFE_RCK Reg, int Data) { + if (usb_enabled) + USB_Sdr1kSRLoad((BYTE) Reg, (BYTE) Data); + else { + static int choose[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01}; + int i; + //Shift data into registers on RFE + //parallel_mutex.WaitOne(); + for (i = 0; i < 8; i++) { + int mask = choose[i]; // Mask the current bit + if ((mask & Data) == 0) { + PWrite((BYTE) (SCLR_NOT + DCDR_NE + transmit_relay + mute_relay)); + Latch(BPF); + PWrite((BYTE) (SCLR_NOT + DCDR_NE + SCK + transmit_relay + mute_relay)); + } else { // Current bit = 1 { + PWrite((BYTE) (SCLR_NOT + DCDR_NE + SER + transmit_relay + mute_relay)); + Latch(BPF); + PWrite((BYTE) (SCLR_NOT + DCDR_NE + SER + SCK + transmit_relay + mute_relay)); + } + Latch(BPF); + PWrite((BYTE) (SCLR_NOT + DCDR_NE + transmit_relay + mute_relay)); + Latch(BPF); + } + RCKStrobe(FALSE, Reg); // Strobe Register Clock + //parallel_mutex.ReleaseMutex(); + } +} + +PUBLIC void ResetRFE(void) { + //Reset all RFE shift registers to zero output + //parallel_mutex.WaitOne(); + RCKStrobe(TRUE, IC11); + RCKStrobe(TRUE, IC7); + RCKStrobe(TRUE, IC10); + RCKStrobe(TRUE, IC9); + //parallel_mutex.ReleaseMutex(); +} + +PUBLIC BOOL getAMP_Relay (void) { return (ic7_memory & AMP_RLYS) != 0; } +PUBLIC BOOL setAMP_Relay (BOOL value) { + //Set or reset LNA relay + if (value) ic7_memory |= AMP_RLYS; + else ic7_memory &= ~(AMP_RLYS); + SRLoad(IC7, ic7_memory); +} + +PUBLIC BOOL getATTN_Relay (void) { return (ic7_memory & ATTN_RLY) != 0; } +PUBLIC void setATTN_Relay (BOOL value) { + if (value) ic7_memory |= ATTN_RLY; + else ic7_memory &= ~(ATTN_RLY); + SRLoad(IC7, ic7_memory); +} + +PUBLIC BOOL getXVTR_TR_Relay (void) { return (ic7_memory & XVTR_TR_RLY) != 0; } +PUBLIC BOOL setXVTR_TR_Relay (BOOL value) { + if (value) ic7_memory |= XVTR_TR_RLY; + else ic7_memory &= ~(XVTR_TR_RLY); + SRLoad(IC7, ic7_memory); +} + +PUBLIC BOOL getXVTR_Relay (void) { return (ic7_memory & XVTR_RLY) != 0; } +PUBLIC BOOL setXVTR_Relay (BOOL value) { + if (value) ic7_memory |= XVTR_RLY; + else ic7_memory &= ~(XVTR_RLY); + SRLoad(IC7, ic7_memory); +} + +PUBLIC BOOL getIMPULSE_Relay (void) { return (ic7_memory & IMPULSE_RLY) != 0; } +PUBLIC BOOL setIMPULSE_Relay (BOOL value) { + if (value) ic7_memory |= IMPULSE_RLY; + else ic7_memory &= ~(IMPULSE_RLY); + SRLoad(IC7, ic7_memory); +} + +PUBLIC void Impulse(void) { + //Send a single impulse to the QSD + SRLoad(IC7, (ic7_memory | IMPULSE)); + SRLoad(IC7, ic7_memory); +} + +PUBLIC void PA_SetLPF(int i) { + int temp = ic11_memory; + switch(i) { + case PA_LPF_OFF: // 0 + ic11_memory &= ~(0x07); // clear bits 0, 1 and 2 + break; + case PA_LPF_12_10: // 1 + ic11_memory = (ic11_memory | 0x01) & ~(0x06); // set bit 0, clear bits 1,2 + break; + case PA_LPF_17_15: // 2 + ic11_memory = (ic11_memory | 0x02) & ~(0x05); // set bit 1, clear bits 0,2 + break; + case PA_LPF_30_20: // 3 + ic11_memory = (ic11_memory | 0x03) & ~(0x04); // set bits 0,1, clear bit 2 + break; + case PA_LPF_60_40: // 4 + ic11_memory = (ic11_memory | 0x04) & ~(0x03); // set bit 2, clear bits 0,1 + break; + case PA_LPF_80: // 5 + ic11_memory = (ic11_memory | 0x05) & ~(0x02); // set bits 0,2, clear bit 1 + break; + case PA_LPF_160: // 6 + ic11_memory = (ic11_memory | 0x06) & ~(0x01); // set bits 1,2, clear bit 0 + break; + } + if (temp != ic11_memory) + SRLoad(IC11, ic11_memory); +} + +PUBLIC BOOL getPA_TransmitRelay (void) { return ((ic11_memory & PATR) != 0); } +PUBLIC BOOL setPA_TransmitRelay (BOOL value) { + int temp = ic11_memory; + if (value) ic11_memory |= PATR; + else ic11_memory &= ~(PATR); + if (temp != ic11_memory) + SRLoad(IC11, ic11_memory); +} + +PUBLIC BOOL getPA_BiasOn (void) { return ((ic7_memory & PA_BIAS_NOT) != 0); } +PUBLIC BOOL setPA_BiasOn (BOOL value) { + int temp = ic7_memory; + if (value) ic7_memory &= ~(PA_BIAS_NOT); + else ic7_memory |= PA_BIAS_NOT; + if (temp != ic7_memory) + SRLoad(IC7, ic7_memory); +} + +PUBLIC BYTE PA_GetADC(int chan) { + short num = 0; + int i; + // get ADC on amplifier + // 0 for forward power, 1 for reverse + + if (usb_enabled) { + int data = USB_Sdr1kGetADC(); + if (chan == 0) return (BYTE) (data & 255); + else return (BYTE) (data >> 8); + } + + //dataline_mutex.WaitOne(); + //parallel_mutex.WaitOne(); + + ic11_memory &= ~(ADC_CS_NOT); // CS not goes low + SRLoad(IC11, ic11_memory); + + ic11_memory |= ADC_DI; // set DI bit high for start bit + SRLoad(IC11, ic11_memory); + + ic11_memory |= ADC_CLK; // clock it into shift register + SRLoad(IC11, ic11_memory); + ic11_memory &= ~(ADC_CLK); + SRLoad(IC11, ic11_memory); + + // set DI bit high for single ended -- done since DI is already high + ic11_memory |= ADC_CLK; // clock it into shift register + SRLoad(IC11, ic11_memory); + ic11_memory &= ~(ADC_CLK); + SRLoad(IC11, ic11_memory); + + if (chan == PA_FORWARD_PWR) { + ic11_memory &= ~(ADC_DI); // set DI bit low for Channel 0 + SRLoad(IC11, ic11_memory); + } else { + // set DI bit high for Channel 1 -- done since DI is already high + } + + ic11_memory |= ADC_CLK; // clock it into shift register + SRLoad(IC11, ic11_memory); + ic11_memory &= ~(ADC_CLK); + SRLoad(IC11, ic11_memory); + + for(i = 0; i < 8; i++) { // read 15 bits out of DO + ic11_memory |= ADC_CLK; // clock high + SRLoad(IC11, ic11_memory); + ic11_memory &= ~(ADC_CLK); // clock low + SRLoad(IC11, ic11_memory); + + if ((StatusPort() & (BYTE) PA_DATA) != 0) // read DO + num++; // add bit + + if (i != 7) num <<= 1; + } + + ic11_memory |= ADC_CS_NOT; // CS not goes high + SRLoad(IC11, ic11_memory); + + //dataline_mutex.ReleaseMutex(); + //parallel_mutex.ReleaseMutex(); + + return (BYTE) (num); +} + +PUBLIC BOOL PA_ATUTune(ATUTuneMode mode) { + int count = 0, delay = 0; + + //dataline_mutex.WaitOne(); + + ic11_memory &= ~(ATUCTL); + + SRLoad(IC11, ic11_memory); + switch (mode) { + case BYPASS: delay = 250; break; + case MEMORY: delay = 2000; break; + case FULL: delay = 3250; break; + } + + Sleep(delay); + ic11_memory |= ATUCTL; + SRLoad(IC11, ic11_memory); + + if (mode == MEMORY || mode == FULL) { + while ((StatusPort() & (BYTE) PA_DATA) != 0) { // wait for low output from ATU + Sleep(50); + if (count++ > 100) return FALSE; + } + count = 0; + while ((StatusPort() & (BYTE) PA_DATA) == 0) { // wait for high output from ATU + Sleep(50); + if (count++ > 100) return FALSE; + } + Sleep(1000); + } + + //dataline_mutex.ReleaseMutex(); + + return TRUE; +} diff --git a/pyhw2/hardware.i b/pyhw2/hardware.i new file mode 100644 index 0000000..99a24ff --- /dev/null +++ b/pyhw2/hardware.i @@ -0,0 +1,5 @@ +%module sdr1khw +%{ +#include "hardware.h" +%} +%include "hardware.h" diff --git a/pyhw2/hardware_wrap.c b/pyhw2/hardware_wrap.c new file mode 100644 index 0000000..b169522 --- /dev/null +++ b/pyhw2/hardware_wrap.c @@ -0,0 +1,3927 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.22 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#define SWIGPYTHON + +#include "Python.h" + +/*************************************************************** -*- c -*- + * python/precommon.swg + * + * Rename all exported symbols from common.swg, to avoid symbol + * clashes if multiple interpreters are included + * + ************************************************************************/ + +#define SWIG_TypeRegister SWIG_Python_TypeRegister +#define SWIG_TypeCheck SWIG_Python_TypeCheck +#define SWIG_TypeCast SWIG_Python_TypeCast +#define SWIG_TypeDynamicCast SWIG_Python_TypeDynamicCast +#define SWIG_TypeName SWIG_Python_TypeName +#define SWIG_TypePrettyName SWIG_Python_TypePrettyName +#define SWIG_TypeQuery SWIG_Python_TypeQuery +#define SWIG_TypeClientData SWIG_Python_TypeClientData +#define SWIG_PackData SWIG_Python_PackData +#define SWIG_UnpackData SWIG_Python_UnpackData + + +/*********************************************************************** + * common.swg + * + * This file contains generic SWIG runtime support for pointer + * type checking as well as a few commonly used macros to control + * external linkage. + * + * Author : David Beazley (beazley@cs.uchicago.edu) + * + * Copyright (c) 1999-2000, The University of Chicago + * + * This file may be freely redistributed without license or fee provided + * this copyright message remains intact. + ************************************************************************/ + +#include <string.h> + +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(_MSC_VER) || defined(__GNUC__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT(a) a +# define SWIGIMPORT(a) extern a +# else +# define SWIGEXPORT(a) __declspec(dllexport) a +# define SWIGIMPORT(a) extern a +# endif +# else +# if defined(__BORLANDC__) +# define SWIGEXPORT(a) a _export +# define SWIGIMPORT(a) a _export +# else +# define SWIGEXPORT(a) a +# define SWIGIMPORT(a) a +# endif +# endif +#else +# define SWIGEXPORT(a) a +# define SWIGIMPORT(a) a +#endif + +#ifdef SWIG_GLOBAL +# define SWIGRUNTIME(a) SWIGEXPORT(a) +#else +# define SWIGRUNTIME(a) static a +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +typedef struct swig_type_info { + const char *name; + swig_converter_func converter; + const char *str; + void *clientdata; + swig_dycast_func dcast; + struct swig_type_info *next; + struct swig_type_info *prev; +} swig_type_info; + +#ifdef SWIG_NOINCLUDE + +SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *); +SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *); +SWIGIMPORT(void *) SWIG_TypeCast(swig_type_info *, void *); +SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **); +SWIGIMPORT(const char *) SWIG_TypeName(const swig_type_info *); +SWIGIMPORT(const char *) SWIG_TypePrettyName(const swig_type_info *); +SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *); +SWIGIMPORT(void) SWIG_TypeClientData(swig_type_info *, void *); +SWIGIMPORT(char *) SWIG_PackData(char *, void *, int); +SWIGIMPORT(char *) SWIG_UnpackData(char *, void *, int); + +#else + +static swig_type_info *swig_type_list = 0; +static swig_type_info **swig_type_list_handle = &swig_type_list; + +/* Register a type mapping with the type-checking */ +SWIGRUNTIME(swig_type_info *) +SWIG_TypeRegister(swig_type_info *ti) { + swig_type_info *tc, *head, *ret, *next; + /* Check to see if this type has already been registered */ + tc = *swig_type_list_handle; + while (tc) { + if (strcmp(tc->name, ti->name) == 0) { + /* Already exists in the table. Just add additional types to the list */ + if (tc->clientdata) ti->clientdata = tc->clientdata; + head = tc; + next = tc->next; + goto l1; + } + tc = tc->prev; + } + head = ti; + next = 0; + + /* Place in list */ + ti->prev = *swig_type_list_handle; + *swig_type_list_handle = ti; + + /* Build linked lists */ + l1: + ret = head; + tc = ti + 1; + /* Patch up the rest of the links */ + while (tc->name) { + head->next = tc; + tc->prev = head; + head = tc; + tc++; + } + if (next) next->prev = head; + head->next = next; + return ret; +} + +/* Check the typename */ +SWIGRUNTIME(swig_type_info *) +SWIG_TypeCheck(char *c, swig_type_info *ty) { + swig_type_info *s; + if (!ty) return 0; /* Void pointer */ + s = ty->next; /* First element always just a name */ + do { + if (strcmp(s->name,c) == 0) { + if (s == ty->next) return s; + /* Move s to the top of the linked list */ + s->prev->next = s->next; + if (s->next) { + s->next->prev = s->prev; + } + /* Insert s as second element in the list */ + s->next = ty->next; + if (ty->next) ty->next->prev = s; + ty->next = s; + s->prev = ty; + return s; + } + s = s->next; + } while (s && (s != ty->next)); + return 0; +} + +/* Cast a pointer up an inheritance hierarchy */ +SWIGRUNTIME(void *) +SWIG_TypeCast(swig_type_info *ty, void *ptr) { + if ((!ty) || (!ty->converter)) return ptr; + return (*ty->converter)(ptr); +} + +/* Dynamic pointer casting. Down an inheritance hierarchy */ +SWIGRUNTIME(swig_type_info *) +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* Return the name associated with this type */ +SWIGRUNTIME(const char *) +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME(const char *) +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class<int>" == "Class<int >", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +static int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return *f1 - *f2; + } + return (l1 - f1) - (l2 - f2); +} + +/* + Check type equivalence in a name list like <name1>|<name2>|... +*/ +static int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* Search for a swig_type_info structure */ +SWIGRUNTIME(swig_type_info *) +SWIG_TypeQuery(const char *name) { + swig_type_info *ty = *swig_type_list_handle; + while (ty) { + if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty; + if (ty->name && (strcmp(name,ty->name) == 0)) return ty; + ty = ty->prev; + } + return 0; +} + +/* Set the clientdata field for a type */ +SWIGRUNTIME(void) +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_type_info *tc, *equiv; + if (ti->clientdata == clientdata) return; + ti->clientdata = clientdata; + equiv = ti->next; + while (equiv) { + if (!equiv->converter) { + tc = *swig_type_list_handle; + while (tc) { + if ((strcmp(tc->name, equiv->name) == 0)) + SWIG_TypeClientData(tc,clientdata); + tc = tc->prev; + } + } + equiv = equiv->next; + } +} + +/* Pack binary data into a string */ +SWIGRUNTIME(char *) +SWIG_PackData(char *c, void *ptr, int sz) { + static char hex[17] = "0123456789abcdef"; + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + register unsigned char uu; + for (; u != eu; ++u) { + uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* Unpack binary data from a string */ +SWIGRUNTIME(char *) +SWIG_UnpackData(char *c, void *ptr, int sz) { + register unsigned char uu = 0; + register int d; + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + *u = uu; + } + return c; +} + +#endif + +#ifdef __cplusplus +} +#endif + +/*********************************************************************** + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * Author : David Beazley (beazley@cs.uchicago.edu) + ************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +#define SWIG_PY_INT 1 +#define SWIG_PY_FLOAT 2 +#define SWIG_PY_STRING 3 +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Flags for pointer conversion */ + +#define SWIG_POINTER_EXCEPTION 0x1 +#define SWIG_POINTER_DISOWN 0x2 + +/* Exception handling in wrappers */ +#define SWIG_fail goto fail + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +/* Common SWIG API */ +#define SWIG_ConvertPtr(obj, pp, type, flags) \ + SWIG_Python_ConvertPtr(obj, pp, type, flags) +#define SWIG_NewPointerObj(p, type, flags) \ + SWIG_Python_NewPointerObj(p, type, flags) +#define SWIG_MustGetPtr(p, type, argnum, flags) \ + SWIG_Python_MustGetPtr(p, type, argnum, flags) + +/* Python-specific SWIG API */ +#define SWIG_newvarlink() \ + SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) \ + SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \ + SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags) +#define SWIG_NewPackedObj(ptr, sz, type) \ + SWIG_Python_NewPackedObj(ptr, sz, type) +#define SWIG_InstallConstants(d, constants) \ + SWIG_Python_InstallConstants(d, constants) + +typedef double (*py_objasdbl_conv)(PyObject *obj); + +#ifdef SWIG_NOINCLUDE + +SWIGIMPORT(int) SWIG_Python_ConvertPtr(PyObject *, void **, swig_type_info *, int); +SWIGIMPORT(PyObject *) SWIG_Python_NewPointerObj(void *, swig_type_info *,int own); +SWIGIMPORT(void *) SWIG_Python_MustGetPtr(PyObject *, swig_type_info *, int, int); +SWIGIMPORT(PyObject *) SWIG_Python_newvarlink(void); +SWIGIMPORT(void) SWIG_Python_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *)); +SWIGIMPORT(int) SWIG_Python_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int); +SWIGIMPORT(PyObject *) SWIG_Python_NewPackedObj(void *, int sz, swig_type_info *); +SWIGIMPORT(void) SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]); + + +#else + + +/* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + +typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; +} swig_globalvar; + +typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; +} swig_varlinkobject; + +static PyObject * +swig_varlink_repr(swig_varlinkobject *v) { + v = v; + return PyString_FromString("<Global variables>"); +} + +static int +swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) { + swig_globalvar *var; + flags = flags; + fprintf(fp,"Global variables { "); + for (var = v->vars; var; var=var->next) { + fprintf(fp,"%s", var->name); + if (var->next) fprintf(fp,", "); + } + fprintf(fp," }\n"); + return 0; +} + +static PyObject * +swig_varlink_getattr(swig_varlinkobject *v, char *n) { + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + return (*var->get_attr)(); + } + var = var->next; + } + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + return NULL; +} + +static int +swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + return (*var->set_attr)(p); + } + var = var->next; + } + PyErr_SetString(PyExc_NameError,"Unknown C global variable"); + return 1; +} + +statichere PyTypeObject varlinktype = { + PyObject_HEAD_INIT(0) + 0, /* Number of items in variable part (ob_size) */ + (char *)"swigvarlink", /* Type name (tp_name) */ + sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */ + 0, /* Itemsize (tp_itemsize) */ + 0, /* Deallocator (tp_dealloc) */ + (printfunc) swig_varlink_print, /* Print (tp_print) */ + (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */ + (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + 0, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ +#if PY_VERSION_HEX >= 0x02020000 + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ +#endif +#if PY_VERSION_HEX >= 0x02030200 + 0, /* tp_del */ +#endif +#ifdef COUNT_ALLOCS + /* these must be last */ + 0, /* tp_alloc */ + 0, /* tp_free */ + 0, /* tp_maxalloc */ + 0, /* tp_next */ +#endif +}; + +/* Create a variable linking object for use later */ +SWIGRUNTIME(PyObject *) +SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = 0; + result = PyMem_NEW(swig_varlinkobject,1); + varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */ + result->ob_type = &varlinktype; + result->vars = 0; + result->ob_refcnt = 0; + Py_XINCREF((PyObject *) result); + return ((PyObject*) result); +} + +SWIGRUNTIME(void) +SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v; + swig_globalvar *gv; + v= (swig_varlinkobject *) p; + gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + gv->name = (char *) malloc(strlen(name)+1); + strcpy(gv->name,name); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + v->vars = gv; +} + +/* Convert a pointer value */ +SWIGRUNTIME(int) +SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) { + swig_type_info *tc; + char *c = 0; + static PyObject *SWIG_this = 0; + int newref = 0; + PyObject *pyobj = 0; + + if (!obj) return 0; + if (obj == Py_None) { + *ptr = 0; + return 0; + } +#ifdef SWIG_COBJECT_TYPES + if (!(PyCObject_Check(obj))) { + if (!SWIG_this) + SWIG_this = PyString_FromString("this"); + pyobj = obj; + obj = PyObject_GetAttr(obj,SWIG_this); + newref = 1; + if (!obj) goto type_error; + if (!PyCObject_Check(obj)) { + Py_DECREF(obj); + goto type_error; + } + } + *ptr = PyCObject_AsVoidPtr(obj); + c = (char *) PyCObject_GetDesc(obj); + if (newref) Py_DECREF(obj); + goto cobject; +#else + if (!(PyString_Check(obj))) { + if (!SWIG_this) + SWIG_this = PyString_FromString("this"); + pyobj = obj; + obj = PyObject_GetAttr(obj,SWIG_this); + newref = 1; + if (!obj) goto type_error; + if (!PyString_Check(obj)) { + Py_DECREF(obj); + goto type_error; + } + } + c = PyString_AS_STRING(obj); + /* Pointer values must start with leading underscore */ + if (*c != '_') { + *ptr = (void *) 0; + if (strcmp(c,"NULL") == 0) { + if (newref) { Py_DECREF(obj); } + return 0; + } else { + if (newref) { Py_DECREF(obj); } + goto type_error; + } + } + c++; + c = SWIG_UnpackData(c,ptr,sizeof(void *)); + if (newref) { Py_DECREF(obj); } +#endif + +#ifdef SWIG_COBJECT_TYPES +cobject: +#endif + + if (ty) { + tc = SWIG_TypeCheck(c,ty); + if (!tc) goto type_error; + *ptr = SWIG_TypeCast(tc,(void*) *ptr); + } + + if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) { + PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False); + } + return 0; + +type_error: + PyErr_Clear(); + if (flags & SWIG_POINTER_EXCEPTION) { + if (ty && c) { + PyErr_Format(PyExc_TypeError, + "Type error. Got %s, expected %s", + c, ty->name); + } else { + PyErr_SetString(PyExc_TypeError,"Expected a pointer"); + } + } + return -1; +} + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME(void *) +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { + void *result; + SWIG_Python_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION); + return result; +} + +/* Convert a packed value value */ +SWIGRUNTIME(int) +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) { + swig_type_info *tc; + char *c = 0; + + if ((!obj) || (!PyString_Check(obj))) goto type_error; + c = PyString_AS_STRING(obj); + /* Pointer values must start with leading underscore */ + if (*c != '_') goto type_error; + c++; + c = SWIG_UnpackData(c,ptr,sz); + if (ty) { + tc = SWIG_TypeCheck(c,ty); + if (!tc) goto type_error; + } + return 0; + +type_error: + + if (flags) { + if (ty && c) { + PyErr_Format(PyExc_TypeError, + "Type error. Got %s, expected %s", + c, ty->name); + } else { + PyErr_SetString(PyExc_TypeError,"Expected a pointer"); + } + } + return -1; +} + +/* Create a new pointer object */ +SWIGRUNTIME(PyObject *) +SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) { + PyObject *robj; + if (!ptr) { + Py_INCREF(Py_None); + return Py_None; + } +#ifdef SWIG_COBJECT_TYPES + robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL); +#else + { + char result[1024]; + char *r = result; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + strcpy(r,type->name); + robj = PyString_FromString(result); + } +#endif + if (!robj || (robj == Py_None)) return robj; + if (type->clientdata) { + PyObject *inst; + PyObject *args = Py_BuildValue((char*)"(O)", robj); + Py_DECREF(robj); + inst = PyObject_CallObject((PyObject *) type->clientdata, args); + Py_DECREF(args); + if (inst) { + if (own) { + PyObject_SetAttrString(inst,(char*)"thisown",Py_True); + } + robj = inst; + } + } + return robj; +} + +SWIGRUNTIME(PyObject *) +SWIG_Python_NewPackedObj(void *ptr, int sz, swig_type_info *type) { + char result[1024]; + char *r = result; + if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + strcpy(r,type->name); + return PyString_FromString(result); +} + +/* Install Constants */ +SWIGRUNTIME(void) +SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + int i; + PyObject *obj; + for (i = 0; constants[i].type; i++) { + switch(constants[i].type) { + case SWIG_PY_INT: + obj = PyInt_FromLong(constants[i].lvalue); + break; + case SWIG_PY_FLOAT: + obj = PyFloat_FromDouble(constants[i].dvalue); + break; + case SWIG_PY_STRING: + if (constants[i].pvalue) { + obj = PyString_FromString((char *) constants[i].pvalue); + } else { + Py_INCREF(Py_None); + obj = Py_None; + } + break; + case SWIG_PY_POINTER: + obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d,constants[i].name,obj); + Py_DECREF(obj); + } + } +} + +#endif + +/* Contract support */ + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else + +#ifdef __cplusplus +} +#endif + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_ushort swig_types[0] +#define SWIGTYPE_p_char swig_types[1] +#define SWIGTYPE_p_u_short swig_types[2] +static swig_type_info *swig_types[4]; + +/* -------- TYPES TABLE (END) -------- */ + + +/*----------------------------------------------- + @(target):= _sdr1khw.so + ------------------------------------------------*/ +#define SWIG_init init_sdr1khw + +#define SWIG_name "_sdr1khw" + +/* Auxiliar swig macros that appear in the header */ + +#define SWIG_OLDOBJ 1 +#define SWIG_NEWOBJ SWIG_OLDOBJ + 1 +#define SWIG_PYSTR SWIG_NEWOBJ + 1 + +#ifdef __cplusplus +#define SWIGSTATICINLINE(a) static inline a +#define SWIGSTATIC(a) static a +#define swig_new_array(size,Type) (new Type[(size)]) +#define swig_delete(cptr) delete cptr +#define swig_delete_array(cptr) delete[] cptr +#define swig_const_cast(a,Type) const_cast<Type >(a) +#define swig_static_cast(a,Type) static_cast<Type >(a) +#define swig_reinterpret_cast(a,Type) reinterpret_cast<Type >(a) +#define swig_new_copy(ptr,Type) (new Type(*ptr)) +#define swig_numeric_cast(a,Type) static_cast<Type >(a) + +#else /* C case */ + +#define SWIGSTATICINLINE(a) static a +#define SWIGSTATIC(a) static a +#define swig_new_array(size,Type) ((Type*) malloc((size)*sizeof(Type))) +#define swig_delete(cptr) free((char*)cptr) +#define swig_delete_array(cptr) free((char*)cptr) +#define swig_const_cast(a,Type) (Type)(a) +#define swig_static_cast(a,Type) (Type)(a) +#define swig_reinterpret_cast(a,Type) (Type)(a) +#define swig_numeric_cast(a,Type) (Type)(a) +#define swig_new_copy(ptr,Type) ((Type*)memcpy(malloc(sizeof(Type)),ptr,sizeof(Type))) + +#endif /* __cplusplus */ + + +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_signed_SS_char PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_unsigned_SS_char PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_short PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_unsigned_SS_short PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_int PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_long PyInt_FromLong +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_float PyFloat_FromDouble +/*@@*/ +/*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/ +#define SWIG_From_double PyFloat_FromDouble +/*@@*/ + + +#include "hardware.h" + +extern double DttSP_SampleRate; + +SWIGSTATICINLINE(int) + SWIG_AsVal_double(PyObject *obj, double *val) +{ + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AS_DOUBLE(obj); + return 1; + } + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AS_LONG(obj); + return 1; + } + if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return 1; + } else { + if (!val) PyErr_Clear(); + return 0; + } + } + if (val) { + PyErr_SetString(PyExc_TypeError, "a double is expected"); + } + return 0; +} + + +SWIGSTATICINLINE(double) +SWIG_As_double(PyObject* obj) +{ + double v; + if (!SWIG_AsVal_double(obj, &v)) { + /* + this is needed to make valgrind/purify happier. the other + solution is throw an exception, but since this code should work + with plain C .... + */ + memset((void*)&v, 0, sizeof(double)); + } + return v; +} + +extern int ic11_memory; + +#include <limits.h> + + +SWIGSTATICINLINE(int) + SWIG_CheckLongInRange(long value, long min_value, long max_value, + const char *errmsg) +{ + if (value < min_value) { + if (errmsg) { + PyErr_Format(PyExc_OverflowError, + "value %ld is less than '%s' minimum %ld", + value, errmsg, min_value); + } + return 0; + } else if (value > max_value) { + if (errmsg) { + PyErr_Format(PyExc_OverflowError, + "value %ld is greater than '%s' maximum %ld", + value, errmsg, max_value); + } + return 0; + } + return 1; +} + + +SWIGSTATICINLINE(int) + SWIG_AsVal_long(PyObject * obj, long* val) +{ + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AS_LONG(obj); + return 1; + } + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return 1; + } else { + if (!val) PyErr_Clear(); + return 0; + } + } + if (val) { + PyErr_SetString(PyExc_TypeError, "a long is expected"); + } + return 0; + } + + +#if INT_MAX != LONG_MAX +SWIGSTATICINLINE(int) + SWIG_AsVal_int(PyObject *obj, int *val) +{ + const char* errmsg = val ? "int" : 0; + long v; + if (SWIG_AsVal_long(obj, &v)) { + if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) { + if (val) *val = swig_numeric_cast(v, int); + return 1; + } else { + return 0; + } + } else { + PyErr_Clear(); + } + if (val) { + PyErr_SetString(PyExc_TypeError, "an int is expected"); + } + return 0; +} +#else +SWIGSTATICINLINE(int) + SWIG_AsVal_int(PyObject *obj, int *val) +{ + return SWIG_AsVal_long(obj,(long*)val); +} +#endif + + +SWIGSTATICINLINE(int) +SWIG_As_int(PyObject* obj) +{ + int v; + if (!SWIG_AsVal_int(obj, &v)) { + /* + this is needed to make valgrind/purify happier. the other + solution is throw an exception, but since this code should work + with plain C .... + */ + memset((void*)&v, 0, sizeof(int)); + } + return v; +} + +extern int ic7_memory; +extern BOOL rfe_enabled; +extern BOOL xvtr_enabled; +extern BOOL pa_enabled; +extern BandSetting band_relay; +extern int external_output; +extern int mute_relay; +extern int transmit_relay; +extern int gain_relay; +extern int latch_delay; +extern double dds_clock; +extern int pll_mult; +extern double dds_clock_correction; +extern double sysClock; +extern int ioud_clock; +extern ushort dac_mult; +extern double dds_freq; +extern double if_freq; +extern BOOL if_shift; +extern BOOL spur_reduction; +extern double dds_step_size; +extern int sample_rate; +extern int fft_length; +extern double FFT_Bin_Size; +extern int tune_fft; +extern double tune_frac_rel; +extern double vfo_offset; +extern double min_freq; +extern double max_freq; +extern u_short baseAdr; +extern BandPlan curBandPlan; +extern double TWO_TO_THE_48_DIVIDED_BY_200; +extern long last_tuning_word; + +SWIGSTATICINLINE(long) +SWIG_As_long(PyObject* obj) +{ + long v; + if (!SWIG_AsVal_long(obj, &v)) { + /* + this is needed to make valgrind/purify happier. the other + solution is throw an exception, but since this code should work + with plain C .... + */ + memset((void*)&v, 0, sizeof(long)); + } + return v; +} + +extern BOOL usb_enabled; +extern BOOL openPort(char *); + +/* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */ +SWIGSTATIC(int) +SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize) +{ + static swig_type_info* pchar_info = 0; + char* vptr = 0; + if (!pchar_info) pchar_info = SWIG_TypeQuery("char *"); + if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) { + if (cptr) *cptr = vptr; + if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0; + return SWIG_OLDOBJ; + } else { + if (PyString_Check(obj)) { + if (cptr) { + *cptr = PyString_AS_STRING(obj); + if (psize) { + *psize = PyString_GET_SIZE(obj) + 1; + } + } + return SWIG_PYSTR; + } + } + if (cptr) { + PyErr_SetString(PyExc_TypeError, "a string is expected"); + } + return 0; +} + + +SWIGSTATICINLINE(int) +SWIG_AsCharPtr(PyObject *obj, char **val) +{ + char* cptr = 0; + if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) { + if (val) *val = cptr; + return 1; + } + if (val) { + PyErr_SetString(PyExc_TypeError, "a char* is expected"); + } + return 0; +} + +extern void closePort(void); +extern void USB_Sdr1kLatch(int,BYTE); + +SWIGSTATICINLINE(int) + SWIG_AsVal_unsigned_SS_long(PyObject * obj, unsigned long *val) +{ + if (PyInt_Check(obj)) { + long v = PyInt_AS_LONG(obj); + if (v >= 0) { + if (val) *val = v; + return 1; + } + } + if (PyLong_Check(obj)) { + unsigned long v = PyLong_AsUnsignedLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return 1; + } else { + if (!val) PyErr_Clear(); + return 0; + } + } + if (val) { + PyErr_SetString(PyExc_TypeError, "an unsigned long is expected"); + } + return 0; +} + + +SWIGSTATICINLINE(int) + SWIG_CheckUnsignedLongInRange(unsigned long value, + unsigned long max_value, + const char *errmsg) +{ + if (value > max_value) { + if (errmsg) { + PyErr_Format(PyExc_OverflowError, + "value %ld is greater than '%s' minimum %ld", + value, errmsg, max_value); + } + return 0; + } + return 1; + } + + +SWIGSTATICINLINE(int) + SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val) +{ + const char* errmsg = val ? "unsigned char" : 0; + unsigned long v; + if (SWIG_AsVal_unsigned_SS_long(obj, &v)) { + if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) { + if (val) *val = swig_numeric_cast(v, unsigned char); + return 1; + } else { + return 0; + } + } else { + PyErr_Clear(); + } + if (val) { + PyErr_SetString(PyExc_TypeError, "an unsigned char is expected"); + } + return 0; +} + + +SWIGSTATICINLINE(unsigned char) +SWIG_As_unsigned_SS_char(PyObject* obj) +{ + unsigned char v; + if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) { + /* + this is needed to make valgrind/purify happier. the other + solution is throw an exception, but since this code should work + with plain C .... + */ + memset((void*)&v, 0, sizeof(unsigned char)); + } + return v; +} + + +SWIGSTATICINLINE(int) +SWIG_Check_int(PyObject* obj) +{ + return SWIG_AsVal_int(obj, (int*)0); +} + + +SWIGSTATICINLINE(int) +SWIG_Check_unsigned_SS_char(PyObject* obj) +{ + return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0); +} + +extern BYTE USB_Sdr1kGetStatusPort(void); +extern int USB_Sdr1kGetADC(void); +extern void USB_Sdr1kDDSReset(void); +extern void USB_Sdr1kDDSWrite(BYTE,BYTE); +extern void USB_Sdr1kSRLoad(BYTE,BYTE); +extern void DttSP_ChangeOsc(double); + +SWIGSTATICINLINE(int) +SWIG_Check_double(PyObject* obj) +{ + return SWIG_AsVal_double(obj, (double*)0); +} + +extern void Init(void); +extern void PowerOn(void); +extern void StandBy(void); +extern void Impulse(void); +extern BYTE StatusPort(void); +extern void SetExt(ExtPin); +extern void ResExt(ExtPin); +extern BOOL PinValue(ExtPin); +extern void SetBPF(double); +extern void TestPort(void); +extern void RCKStrobe(BOOL,RFE_RCK); +extern void SRLoad(RFE_RCK,int); +extern void ResetRFE(void); +extern void PA_SetLPF(int); +extern BYTE PA_GetADC(int); +extern BOOL PA_ATUTune(ATUTuneMode); +extern BOOL getEnableLPF0(void); +extern void setEnableLPF0(BOOL); +extern BOOL getExtended(void); +extern void setExtended(BOOL); +extern BOOL getX2Enabled(void); +extern void setX2Enabled(BOOL); +extern int getX2Delay(void); +extern void setX2Delay(int); +extern BOOL getRFE_Enabled(void); +extern void setRFE_Enabled(BOOL); +extern BOOL getPA_Enabled(void); +extern void setPA_Enabled(BOOL); +extern BOOL getXVTR_Enabled(void); +extern BOOL setXVTR_Enabled(BOOL); +extern BOOL getUSB_Enabled(void); +extern void setUSB_Enabled(BOOL); +extern XVTRTRMode getCurrentXVTRTRMode(void); +extern void setCurrentXVTRTRMode(XVTRTRMode); +extern int getLatchDelay(void); +extern void setLatchDelay(int); +extern double getMinFreq(void); +extern double getMaxFreq(void); +extern u_short getBaseAddr(void); +extern u_short setBaseAddr(u_short); +extern BandSetting getBandRelay(void); +extern void setBandRelay(BandSetting); +extern BOOL getTransmitRelay(void); +extern void setTransmitRelay(BOOL); +extern BOOL getMuteRelay(void); +extern void setMuteRelay(BOOL); +extern BOOL getGainRelay(void); +extern void setGainRelay(BOOL); +extern int getExternalOutput(void); +extern void setExternalOutput(int); +extern double getDDSClockCorrection(void); +extern void setDDSClockCorrection(double); +extern int getPLLMult(void); +extern void setPLLMult(int); +extern double getDDSClock(void); +extern void setDDSClock(double); +extern BOOL getIFShift(void); +extern void setIFShift(BOOL); +extern BOOL getSpurReduction(void); +extern BOOL setSpurReduction(BOOL); +extern double getIFFreq(void); +extern void setIFFreq(double); +extern double getDDSFreq(void); +extern void setDDSFreq(double); +extern int getSampleRate(void); +extern void setSampleRate(int); +extern int getFFTLength(void); +extern void setFFTLength(int); +extern int getTuneFFT(void); +extern double getTuneFracRel(void); +extern double getVFOOffset(void); +extern void setVFOOffset(double); +extern int getIOUDClock(void); +extern void setIOUDClock(int); +extern u_short getDACMult(void); +extern void setDACMult(u_short); +extern BOOL getAMP_Relay(void); +extern BOOL setAMP_Relay(BOOL); +extern BOOL getATTN_Relay(void); +extern void setATTN_Relay(BOOL); +extern BOOL getXVTR_TR_Relay(void); +extern BOOL setXVTR_TR_Relay(BOOL); +extern BOOL getXVTR_Relay(void); +extern BOOL setXVTR_Relay(BOOL); +extern BOOL getIMPULSE_Relay(void); +extern BOOL setIMPULSE_Relay(BOOL); +extern BOOL getPA_TransmitRelay(void); +extern BOOL setPA_TransmitRelay(BOOL); +extern BOOL getPA_BiasOn(void); +extern BOOL setPA_BiasOn(BOOL); +#ifdef __cplusplus +extern "C" { +#endif +static int _wrap_DttSP_SampleRate_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'DttSP_SampleRate (double)'"); + return 1; + } + DttSP_SampleRate = temp; + } + return 0; +} + + +static PyObject *_wrap_DttSP_SampleRate_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)DttSP_SampleRate); + return pyobj; +} + + +static int _wrap_ic11_memory_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ic11_memory (int)'"); + return 1; + } + ic11_memory = temp; + } + return 0; +} + + +static PyObject *_wrap_ic11_memory_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)ic11_memory); + return pyobj; +} + + +static int _wrap_ic7_memory_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ic7_memory (int)'"); + return 1; + } + ic7_memory = temp; + } + return 0; +} + + +static PyObject *_wrap_ic7_memory_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)ic7_memory); + return pyobj; +} + + +static int _wrap_rfe_enabled_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'rfe_enabled (BOOL)'"); + return 1; + } + rfe_enabled = temp; + } + return 0; +} + + +static PyObject *_wrap_rfe_enabled_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)rfe_enabled); + return pyobj; +} + + +static int _wrap_xvtr_enabled_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'xvtr_enabled (BOOL)'"); + return 1; + } + xvtr_enabled = temp; + } + return 0; +} + + +static PyObject *_wrap_xvtr_enabled_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)xvtr_enabled); + return pyobj; +} + + +static int _wrap_pa_enabled_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pa_enabled (BOOL)'"); + return 1; + } + pa_enabled = temp; + } + return 0; +} + + +static PyObject *_wrap_pa_enabled_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)pa_enabled); + return pyobj; +} + + +static int _wrap_band_relay_set(PyObject *_val) { + { + if (sizeof(int) != sizeof(band_relay)) { + PyErr_SetString(PyExc_TypeError, "enum variable 'band_relay' can not be set"); + return 1; + } + if (!SWIG_AsVal_int(_val, (int*)(void*)&(band_relay))) { + return 1; + } + } + return 0; +} + + +static PyObject *_wrap_band_relay_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)band_relay); + return pyobj; +} + + +static int _wrap_external_output_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'external_output (int)'"); + return 1; + } + external_output = temp; + } + return 0; +} + + +static PyObject *_wrap_external_output_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)external_output); + return pyobj; +} + + +static int _wrap_mute_relay_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'mute_relay (int)'"); + return 1; + } + mute_relay = temp; + } + return 0; +} + + +static PyObject *_wrap_mute_relay_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)mute_relay); + return pyobj; +} + + +static int _wrap_transmit_relay_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'transmit_relay (int)'"); + return 1; + } + transmit_relay = temp; + } + return 0; +} + + +static PyObject *_wrap_transmit_relay_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)transmit_relay); + return pyobj; +} + + +static int _wrap_gain_relay_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'gain_relay (int)'"); + return 1; + } + gain_relay = temp; + } + return 0; +} + + +static PyObject *_wrap_gain_relay_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)gain_relay); + return pyobj; +} + + +static int _wrap_latch_delay_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'latch_delay (int)'"); + return 1; + } + latch_delay = temp; + } + return 0; +} + + +static PyObject *_wrap_latch_delay_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)latch_delay); + return pyobj; +} + + +static int _wrap_dds_clock_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_clock (double)'"); + return 1; + } + dds_clock = temp; + } + return 0; +} + + +static PyObject *_wrap_dds_clock_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)dds_clock); + return pyobj; +} + + +static int _wrap_pll_mult_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pll_mult (int)'"); + return 1; + } + pll_mult = temp; + } + return 0; +} + + +static PyObject *_wrap_pll_mult_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)pll_mult); + return pyobj; +} + + +static int _wrap_dds_clock_correction_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_clock_correction (double)'"); + return 1; + } + dds_clock_correction = temp; + } + return 0; +} + + +static PyObject *_wrap_dds_clock_correction_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)dds_clock_correction); + return pyobj; +} + + +static int _wrap_sysClock_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'sysClock (double)'"); + return 1; + } + sysClock = temp; + } + return 0; +} + + +static PyObject *_wrap_sysClock_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)sysClock); + return pyobj; +} + + +static int _wrap_ioud_clock_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ioud_clock (int)'"); + return 1; + } + ioud_clock = temp; + } + return 0; +} + + +static PyObject *_wrap_ioud_clock_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)ioud_clock); + return pyobj; +} + + +static int _wrap_dac_mult_set(PyObject *_val) { + { + ushort * temp; + if ((SWIG_ConvertPtr(_val, (void **)(&temp), SWIGTYPE_p_ushort, SWIG_POINTER_EXCEPTION)) == -1) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dac_mult (ushort)'"); + return 1; + } + dac_mult = *((ushort *) temp); + } + return 0; +} + + +static PyObject *_wrap_dac_mult_get() { + PyObject *pyobj; + + pyobj = SWIG_NewPointerObj((void *)(&dac_mult), SWIGTYPE_p_ushort, 0); + return pyobj; +} + + +static int _wrap_dds_freq_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_freq (double)'"); + return 1; + } + dds_freq = temp; + } + return 0; +} + + +static PyObject *_wrap_dds_freq_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)dds_freq); + return pyobj; +} + + +static int _wrap_if_freq_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'if_freq (double)'"); + return 1; + } + if_freq = temp; + } + return 0; +} + + +static PyObject *_wrap_if_freq_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)if_freq); + return pyobj; +} + + +static int _wrap_if_shift_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'if_shift (BOOL)'"); + return 1; + } + if_shift = temp; + } + return 0; +} + + +static PyObject *_wrap_if_shift_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)if_shift); + return pyobj; +} + + +static int _wrap_spur_reduction_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'spur_reduction (BOOL)'"); + return 1; + } + spur_reduction = temp; + } + return 0; +} + + +static PyObject *_wrap_spur_reduction_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)spur_reduction); + return pyobj; +} + + +static int _wrap_dds_step_size_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_step_size (double)'"); + return 1; + } + dds_step_size = temp; + } + return 0; +} + + +static PyObject *_wrap_dds_step_size_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)dds_step_size); + return pyobj; +} + + +static int _wrap_sample_rate_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'sample_rate (int)'"); + return 1; + } + sample_rate = temp; + } + return 0; +} + + +static PyObject *_wrap_sample_rate_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)sample_rate); + return pyobj; +} + + +static int _wrap_fft_length_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'fft_length (int)'"); + return 1; + } + fft_length = temp; + } + return 0; +} + + +static PyObject *_wrap_fft_length_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)fft_length); + return pyobj; +} + + +static int _wrap_FFT_Bin_Size_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'FFT_Bin_Size (double)'"); + return 1; + } + FFT_Bin_Size = temp; + } + return 0; +} + + +static PyObject *_wrap_FFT_Bin_Size_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)FFT_Bin_Size); + return pyobj; +} + + +static int _wrap_tune_fft_set(PyObject *_val) { + { + int temp = (int) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'tune_fft (int)'"); + return 1; + } + tune_fft = temp; + } + return 0; +} + + +static PyObject *_wrap_tune_fft_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)tune_fft); + return pyobj; +} + + +static int _wrap_tune_frac_rel_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'tune_frac_rel (double)'"); + return 1; + } + tune_frac_rel = temp; + } + return 0; +} + + +static PyObject *_wrap_tune_frac_rel_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)tune_frac_rel); + return pyobj; +} + + +static int _wrap_vfo_offset_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'vfo_offset (double)'"); + return 1; + } + vfo_offset = temp; + } + return 0; +} + + +static PyObject *_wrap_vfo_offset_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)vfo_offset); + return pyobj; +} + + +static int _wrap_min_freq_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'min_freq (double)'"); + return 1; + } + min_freq = temp; + } + return 0; +} + + +static PyObject *_wrap_min_freq_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)min_freq); + return pyobj; +} + + +static int _wrap_max_freq_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'max_freq (double)'"); + return 1; + } + max_freq = temp; + } + return 0; +} + + +static PyObject *_wrap_max_freq_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)max_freq); + return pyobj; +} + + +static int _wrap_baseAdr_set(PyObject *_val) { + { + u_short * temp; + if ((SWIG_ConvertPtr(_val, (void **)(&temp), SWIGTYPE_p_u_short, SWIG_POINTER_EXCEPTION)) == -1) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'baseAdr (u_short)'"); + return 1; + } + baseAdr = *((u_short *) temp); + } + return 0; +} + + +static PyObject *_wrap_baseAdr_get() { + PyObject *pyobj; + + pyobj = SWIG_NewPointerObj((void *)(&baseAdr), SWIGTYPE_p_u_short, 0); + return pyobj; +} + + +static int _wrap_curBandPlan_set(PyObject *_val) { + { + if (sizeof(int) != sizeof(curBandPlan)) { + PyErr_SetString(PyExc_TypeError, "enum variable 'curBandPlan' can not be set"); + return 1; + } + if (!SWIG_AsVal_int(_val, (int*)(void*)&(curBandPlan))) { + return 1; + } + } + return 0; +} + + +static PyObject *_wrap_curBandPlan_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)curBandPlan); + return pyobj; +} + + +static int _wrap_TWO_TO_THE_48_DIVIDED_BY_200_set(PyObject *_val) { + { + double temp = (double) SWIG_As_double(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'TWO_TO_THE_48_DIVIDED_BY_200 (double)'"); + return 1; + } + TWO_TO_THE_48_DIVIDED_BY_200 = temp; + } + return 0; +} + + +static PyObject *_wrap_TWO_TO_THE_48_DIVIDED_BY_200_get() { + PyObject *pyobj; + + pyobj = SWIG_From_double((double)TWO_TO_THE_48_DIVIDED_BY_200); + return pyobj; +} + + +static int _wrap_last_tuning_word_set(PyObject *_val) { + { + long temp = (long) SWIG_As_long(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'last_tuning_word (long)'"); + return 1; + } + last_tuning_word = temp; + } + return 0; +} + + +static PyObject *_wrap_last_tuning_word_get() { + PyObject *pyobj; + + pyobj = SWIG_From_long((long)last_tuning_word); + return pyobj; +} + + +static int _wrap_usb_enabled_set(PyObject *_val) { + { + BOOL temp = (BOOL) SWIG_As_int(_val); + if (PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "C/C++ variable 'usb_enabled (BOOL)'"); + return 1; + } + usb_enabled = temp; + } + return 0; +} + + +static PyObject *_wrap_usb_enabled_get() { + PyObject *pyobj; + + pyobj = SWIG_From_int((int)usb_enabled); + return pyobj; +} + + +static PyObject *_wrap_openPort(PyObject *self, PyObject *args) { + PyObject *resultobj; + char *arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:openPort",&obj0)) goto fail; + if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail; + result = (BOOL)openPort(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_closePort(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":closePort")) goto fail; + closePort(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kLatch(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + BYTE arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kLatch",&obj0,&obj1)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); + if (PyErr_Occurred()) SWIG_fail; + USB_Sdr1kLatch(arg1,arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kGetStatusPort(PyObject *self, PyObject *args) { + PyObject *resultobj; + BYTE result; + + if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kGetStatusPort")) goto fail; + result = (BYTE)USB_Sdr1kGetStatusPort(); + + resultobj = SWIG_From_unsigned_SS_char((unsigned char)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kGetADC(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kGetADC")) goto fail; + result = (int)USB_Sdr1kGetADC(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kDDSReset(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kDDSReset")) goto fail; + USB_Sdr1kDDSReset(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kDDSWrite(PyObject *self, PyObject *args) { + PyObject *resultobj; + BYTE arg1 ; + BYTE arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kDDSWrite",&obj0,&obj1)) goto fail; + arg1 = (BYTE)SWIG_As_unsigned_SS_char(obj0); + if (PyErr_Occurred()) SWIG_fail; + arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); + if (PyErr_Occurred()) SWIG_fail; + USB_Sdr1kDDSWrite(arg1,arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_USB_Sdr1kSRLoad(PyObject *self, PyObject *args) { + PyObject *resultobj; + BYTE arg1 ; + BYTE arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kSRLoad",&obj0,&obj1)) goto fail; + arg1 = (BYTE)SWIG_As_unsigned_SS_char(obj0); + if (PyErr_Occurred()) SWIG_fail; + arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); + if (PyErr_Occurred()) SWIG_fail; + USB_Sdr1kSRLoad(arg1,arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_DttSP_ChangeOsc(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:DttSP_ChangeOsc",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + DttSP_ChangeOsc(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_Init(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":Init")) goto fail; + Init(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_PowerOn(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":PowerOn")) goto fail; + PowerOn(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_StandBy(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":StandBy")) goto fail; + StandBy(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_Impulse(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":Impulse")) goto fail; + Impulse(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_StatusPort(PyObject *self, PyObject *args) { + PyObject *resultobj; + BYTE result; + + if(!PyArg_ParseTuple(args,(char *)":StatusPort")) goto fail; + result = (BYTE)StatusPort(); + + resultobj = SWIG_From_unsigned_SS_char((unsigned char)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_SetExt(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:SetExt",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + SetExt((ExtPin )arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_ResExt(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:ResExt",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + ResExt((ExtPin )arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_PinValue(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:PinValue",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)PinValue((ExtPin )arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_SetBPF(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:SetBPF",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + SetBPF(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_TestPort(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":TestPort")) goto fail; + TestPort(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_RCKStrobe(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + int arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:RCKStrobe",&obj0,&obj1)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + arg2 = (int)SWIG_As_int(obj1); + if (PyErr_Occurred()) SWIG_fail; + RCKStrobe(arg1,(RFE_RCK )arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_SRLoad(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + int arg2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"OO:SRLoad",&obj0,&obj1)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + arg2 = (int)SWIG_As_int(obj1); + if (PyErr_Occurred()) SWIG_fail; + SRLoad((RFE_RCK )arg1,arg2); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_ResetRFE(PyObject *self, PyObject *args) { + PyObject *resultobj; + + if(!PyArg_ParseTuple(args,(char *)":ResetRFE")) goto fail; + ResetRFE(); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_PA_SetLPF(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:PA_SetLPF",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + PA_SetLPF(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_PA_GetADC(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + BYTE result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:PA_GetADC",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BYTE)PA_GetADC(arg1); + + resultobj = SWIG_From_unsigned_SS_char((unsigned char)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_PA_ATUTune(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:PA_ATUTune",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)PA_ATUTune((ATUTuneMode )arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getEnableLPF0(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getEnableLPF0")) goto fail; + result = (BOOL)getEnableLPF0(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setEnableLPF0(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setEnableLPF0",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setEnableLPF0(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getExtended(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getExtended")) goto fail; + result = (BOOL)getExtended(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setExtended(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setExtended",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setExtended(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getX2Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getX2Enabled")) goto fail; + result = (BOOL)getX2Enabled(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setX2Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setX2Enabled",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setX2Enabled(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getX2Delay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getX2Delay")) goto fail; + result = (int)getX2Delay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setX2Delay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setX2Delay",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setX2Delay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getRFE_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getRFE_Enabled")) goto fail; + result = (BOOL)getRFE_Enabled(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setRFE_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setRFE_Enabled",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setRFE_Enabled(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getPA_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getPA_Enabled")) goto fail; + result = (BOOL)getPA_Enabled(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setPA_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setPA_Enabled",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setPA_Enabled(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getXVTR_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getXVTR_Enabled")) goto fail; + result = (BOOL)getXVTR_Enabled(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setXVTR_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_Enabled",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setXVTR_Enabled(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getUSB_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getUSB_Enabled")) goto fail; + result = (BOOL)getUSB_Enabled(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setUSB_Enabled(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setUSB_Enabled",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setUSB_Enabled(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getCurrentXVTRTRMode(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getCurrentXVTRTRMode")) goto fail; + result = (int)getCurrentXVTRTRMode(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setCurrentXVTRTRMode(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setCurrentXVTRTRMode",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setCurrentXVTRTRMode((XVTRTRMode )arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getLatchDelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getLatchDelay")) goto fail; + result = (int)getLatchDelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setLatchDelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setLatchDelay",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setLatchDelay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getMinFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getMinFreq")) goto fail; + result = (double)getMinFreq(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getMaxFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getMaxFreq")) goto fail; + result = (double)getMaxFreq(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getBaseAddr(PyObject *self, PyObject *args) { + PyObject *resultobj; + u_short result; + + if(!PyArg_ParseTuple(args,(char *)":getBaseAddr")) goto fail; + result = getBaseAddr(); + + { + u_short * resultptr; + resultptr = (u_short *) malloc(sizeof(u_short)); + memmove(resultptr, &result, sizeof(u_short)); + resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1); + } + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setBaseAddr(PyObject *self, PyObject *args) { + PyObject *resultobj; + u_short arg1 ; + u_short result; + u_short *argp1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setBaseAddr",&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&argp1),SWIGTYPE_p_u_short, + SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail; + arg1 = *argp1; + result = setBaseAddr(arg1); + + { + u_short * resultptr; + resultptr = (u_short *) malloc(sizeof(u_short)); + memmove(resultptr, &result, sizeof(u_short)); + resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1); + } + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getBandRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getBandRelay")) goto fail; + result = (int)getBandRelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setBandRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setBandRelay",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setBandRelay((BandSetting )arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getTransmitRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getTransmitRelay")) goto fail; + result = (BOOL)getTransmitRelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setTransmitRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setTransmitRelay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setTransmitRelay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getMuteRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getMuteRelay")) goto fail; + result = (BOOL)getMuteRelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setMuteRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setMuteRelay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setMuteRelay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getGainRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getGainRelay")) goto fail; + result = (BOOL)getGainRelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setGainRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setGainRelay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setGainRelay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getExternalOutput(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getExternalOutput")) goto fail; + result = (int)getExternalOutput(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setExternalOutput(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setExternalOutput",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setExternalOutput(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getDDSClockCorrection(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getDDSClockCorrection")) goto fail; + result = (double)getDDSClockCorrection(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setDDSClockCorrection(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setDDSClockCorrection",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + setDDSClockCorrection(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getPLLMult(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getPLLMult")) goto fail; + result = (int)getPLLMult(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setPLLMult(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setPLLMult",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setPLLMult(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getDDSClock(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getDDSClock")) goto fail; + result = (double)getDDSClock(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setDDSClock(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setDDSClock",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + setDDSClock(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getIFShift(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getIFShift")) goto fail; + result = (BOOL)getIFShift(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setIFShift(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setIFShift",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setIFShift(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getSpurReduction(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getSpurReduction")) goto fail; + result = (BOOL)getSpurReduction(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setSpurReduction(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setSpurReduction",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setSpurReduction(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getIFFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getIFFreq")) goto fail; + result = (double)getIFFreq(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setIFFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setIFFreq",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + setIFFreq(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getDDSFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getDDSFreq")) goto fail; + result = (double)getDDSFreq(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setDDSFreq(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setDDSFreq",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + setDDSFreq(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getSampleRate(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getSampleRate")) goto fail; + result = (int)getSampleRate(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setSampleRate(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setSampleRate",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setSampleRate(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getFFTLength(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getFFTLength")) goto fail; + result = (int)getFFTLength(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setFFTLength(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setFFTLength",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setFFTLength(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getTuneFFT(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getTuneFFT")) goto fail; + result = (int)getTuneFFT(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getTuneFracRel(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getTuneFracRel")) goto fail; + result = (double)getTuneFracRel(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getVFOOffset(PyObject *self, PyObject *args) { + PyObject *resultobj; + double result; + + if(!PyArg_ParseTuple(args,(char *)":getVFOOffset")) goto fail; + result = (double)getVFOOffset(); + + resultobj = SWIG_From_double((double)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setVFOOffset(PyObject *self, PyObject *args) { + PyObject *resultobj; + double arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setVFOOffset",&obj0)) goto fail; + arg1 = (double)SWIG_As_double(obj0); + if (PyErr_Occurred()) SWIG_fail; + setVFOOffset(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getIOUDClock(PyObject *self, PyObject *args) { + PyObject *resultobj; + int result; + + if(!PyArg_ParseTuple(args,(char *)":getIOUDClock")) goto fail; + result = (int)getIOUDClock(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setIOUDClock(PyObject *self, PyObject *args) { + PyObject *resultobj; + int arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setIOUDClock",&obj0)) goto fail; + arg1 = (int)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setIOUDClock(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getDACMult(PyObject *self, PyObject *args) { + PyObject *resultobj; + u_short result; + + if(!PyArg_ParseTuple(args,(char *)":getDACMult")) goto fail; + result = getDACMult(); + + { + u_short * resultptr; + resultptr = (u_short *) malloc(sizeof(u_short)); + memmove(resultptr, &result, sizeof(u_short)); + resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1); + } + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setDACMult(PyObject *self, PyObject *args) { + PyObject *resultobj; + u_short arg1 ; + u_short *argp1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setDACMult",&obj0)) goto fail; + if ((SWIG_ConvertPtr(obj0,(void **)(&argp1),SWIGTYPE_p_u_short, + SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail; + arg1 = *argp1; + setDACMult(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getAMP_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getAMP_Relay")) goto fail; + result = (BOOL)getAMP_Relay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setAMP_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setAMP_Relay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setAMP_Relay(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getATTN_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getATTN_Relay")) goto fail; + result = (BOOL)getATTN_Relay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setATTN_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setATTN_Relay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + setATTN_Relay(arg1); + + Py_INCREF(Py_None); resultobj = Py_None; + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getXVTR_TR_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getXVTR_TR_Relay")) goto fail; + result = (BOOL)getXVTR_TR_Relay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setXVTR_TR_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_TR_Relay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setXVTR_TR_Relay(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getXVTR_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getXVTR_Relay")) goto fail; + result = (BOOL)getXVTR_Relay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setXVTR_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_Relay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setXVTR_Relay(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getIMPULSE_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getIMPULSE_Relay")) goto fail; + result = (BOOL)getIMPULSE_Relay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setIMPULSE_Relay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setIMPULSE_Relay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setIMPULSE_Relay(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getPA_TransmitRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getPA_TransmitRelay")) goto fail; + result = (BOOL)getPA_TransmitRelay(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setPA_TransmitRelay(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setPA_TransmitRelay",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setPA_TransmitRelay(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_getPA_BiasOn(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL result; + + if(!PyArg_ParseTuple(args,(char *)":getPA_BiasOn")) goto fail; + result = (BOOL)getPA_BiasOn(); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyObject *_wrap_setPA_BiasOn(PyObject *self, PyObject *args) { + PyObject *resultobj; + BOOL arg1 ; + BOOL result; + PyObject * obj0 = 0 ; + + if(!PyArg_ParseTuple(args,(char *)"O:setPA_BiasOn",&obj0)) goto fail; + arg1 = (BOOL)SWIG_As_int(obj0); + if (PyErr_Occurred()) SWIG_fail; + result = (BOOL)setPA_BiasOn(arg1); + + resultobj = SWIG_From_int((int)result); + return resultobj; + fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { (char *)"openPort", _wrap_openPort, METH_VARARGS, NULL }, + { (char *)"closePort", _wrap_closePort, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kLatch", _wrap_USB_Sdr1kLatch, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kGetStatusPort", _wrap_USB_Sdr1kGetStatusPort, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kGetADC", _wrap_USB_Sdr1kGetADC, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kDDSReset", _wrap_USB_Sdr1kDDSReset, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kDDSWrite", _wrap_USB_Sdr1kDDSWrite, METH_VARARGS, NULL }, + { (char *)"USB_Sdr1kSRLoad", _wrap_USB_Sdr1kSRLoad, METH_VARARGS, NULL }, + { (char *)"DttSP_ChangeOsc", _wrap_DttSP_ChangeOsc, METH_VARARGS, NULL }, + { (char *)"Init", _wrap_Init, METH_VARARGS, NULL }, + { (char *)"PowerOn", _wrap_PowerOn, METH_VARARGS, NULL }, + { (char *)"StandBy", _wrap_StandBy, METH_VARARGS, NULL }, + { (char *)"Impulse", _wrap_Impulse, METH_VARARGS, NULL }, + { (char *)"StatusPort", _wrap_StatusPort, METH_VARARGS, NULL }, + { (char *)"SetExt", _wrap_SetExt, METH_VARARGS, NULL }, + { (char *)"ResExt", _wrap_ResExt, METH_VARARGS, NULL }, + { (char *)"PinValue", _wrap_PinValue, METH_VARARGS, NULL }, + { (char *)"SetBPF", _wrap_SetBPF, METH_VARARGS, NULL }, + { (char *)"TestPort", _wrap_TestPort, METH_VARARGS, NULL }, + { (char *)"RCKStrobe", _wrap_RCKStrobe, METH_VARARGS, NULL }, + { (char *)"SRLoad", _wrap_SRLoad, METH_VARARGS, NULL }, + { (char *)"ResetRFE", _wrap_ResetRFE, METH_VARARGS, NULL }, + { (char *)"PA_SetLPF", _wrap_PA_SetLPF, METH_VARARGS, NULL }, + { (char *)"PA_GetADC", _wrap_PA_GetADC, METH_VARARGS, NULL }, + { (char *)"PA_ATUTune", _wrap_PA_ATUTune, METH_VARARGS, NULL }, + { (char *)"getEnableLPF0", _wrap_getEnableLPF0, METH_VARARGS, NULL }, + { (char *)"setEnableLPF0", _wrap_setEnableLPF0, METH_VARARGS, NULL }, + { (char *)"getExtended", _wrap_getExtended, METH_VARARGS, NULL }, + { (char *)"setExtended", _wrap_setExtended, METH_VARARGS, NULL }, + { (char *)"getX2Enabled", _wrap_getX2Enabled, METH_VARARGS, NULL }, + { (char *)"setX2Enabled", _wrap_setX2Enabled, METH_VARARGS, NULL }, + { (char *)"getX2Delay", _wrap_getX2Delay, METH_VARARGS, NULL }, + { (char *)"setX2Delay", _wrap_setX2Delay, METH_VARARGS, NULL }, + { (char *)"getRFE_Enabled", _wrap_getRFE_Enabled, METH_VARARGS, NULL }, + { (char *)"setRFE_Enabled", _wrap_setRFE_Enabled, METH_VARARGS, NULL }, + { (char *)"getPA_Enabled", _wrap_getPA_Enabled, METH_VARARGS, NULL }, + { (char *)"setPA_Enabled", _wrap_setPA_Enabled, METH_VARARGS, NULL }, + { (char *)"getXVTR_Enabled", _wrap_getXVTR_Enabled, METH_VARARGS, NULL }, + { (char *)"setXVTR_Enabled", _wrap_setXVTR_Enabled, METH_VARARGS, NULL }, + { (char *)"getUSB_Enabled", _wrap_getUSB_Enabled, METH_VARARGS, NULL }, + { (char *)"setUSB_Enabled", _wrap_setUSB_Enabled, METH_VARARGS, NULL }, + { (char *)"getCurrentXVTRTRMode", _wrap_getCurrentXVTRTRMode, METH_VARARGS, NULL }, + { (char *)"setCurrentXVTRTRMode", _wrap_setCurrentXVTRTRMode, METH_VARARGS, NULL }, + { (char *)"getLatchDelay", _wrap_getLatchDelay, METH_VARARGS, NULL }, + { (char *)"setLatchDelay", _wrap_setLatchDelay, METH_VARARGS, NULL }, + { (char *)"getMinFreq", _wrap_getMinFreq, METH_VARARGS, NULL }, + { (char *)"getMaxFreq", _wrap_getMaxFreq, METH_VARARGS, NULL }, + { (char *)"getBaseAddr", _wrap_getBaseAddr, METH_VARARGS, NULL }, + { (char *)"setBaseAddr", _wrap_setBaseAddr, METH_VARARGS, NULL }, + { (char *)"getBandRelay", _wrap_getBandRelay, METH_VARARGS, NULL }, + { (char *)"setBandRelay", _wrap_setBandRelay, METH_VARARGS, NULL }, + { (char *)"getTransmitRelay", _wrap_getTransmitRelay, METH_VARARGS, NULL }, + { (char *)"setTransmitRelay", _wrap_setTransmitRelay, METH_VARARGS, NULL }, + { (char *)"getMuteRelay", _wrap_getMuteRelay, METH_VARARGS, NULL }, + { (char *)"setMuteRelay", _wrap_setMuteRelay, METH_VARARGS, NULL }, + { (char *)"getGainRelay", _wrap_getGainRelay, METH_VARARGS, NULL }, + { (char *)"setGainRelay", _wrap_setGainRelay, METH_VARARGS, NULL }, + { (char *)"getExternalOutput", _wrap_getExternalOutput, METH_VARARGS, NULL }, + { (char *)"setExternalOutput", _wrap_setExternalOutput, METH_VARARGS, NULL }, + { (char *)"getDDSClockCorrection", _wrap_getDDSClockCorrection, METH_VARARGS, NULL }, + { (char *)"setDDSClockCorrection", _wrap_setDDSClockCorrection, METH_VARARGS, NULL }, + { (char *)"getPLLMult", _wrap_getPLLMult, METH_VARARGS, NULL }, + { (char *)"setPLLMult", _wrap_setPLLMult, METH_VARARGS, NULL }, + { (char *)"getDDSClock", _wrap_getDDSClock, METH_VARARGS, NULL }, + { (char *)"setDDSClock", _wrap_setDDSClock, METH_VARARGS, NULL }, + { (char *)"getIFShift", _wrap_getIFShift, METH_VARARGS, NULL }, + { (char *)"setIFShift", _wrap_setIFShift, METH_VARARGS, NULL }, + { (char *)"getSpurReduction", _wrap_getSpurReduction, METH_VARARGS, NULL }, + { (char *)"setSpurReduction", _wrap_setSpurReduction, METH_VARARGS, NULL }, + { (char *)"getIFFreq", _wrap_getIFFreq, METH_VARARGS, NULL }, + { (char *)"setIFFreq", _wrap_setIFFreq, METH_VARARGS, NULL }, + { (char *)"getDDSFreq", _wrap_getDDSFreq, METH_VARARGS, NULL }, + { (char *)"setDDSFreq", _wrap_setDDSFreq, METH_VARARGS, NULL }, + { (char *)"getSampleRate", _wrap_getSampleRate, METH_VARARGS, NULL }, + { (char *)"setSampleRate", _wrap_setSampleRate, METH_VARARGS, NULL }, + { (char *)"getFFTLength", _wrap_getFFTLength, METH_VARARGS, NULL }, + { (char *)"setFFTLength", _wrap_setFFTLength, METH_VARARGS, NULL }, + { (char *)"getTuneFFT", _wrap_getTuneFFT, METH_VARARGS, NULL }, + { (char *)"getTuneFracRel", _wrap_getTuneFracRel, METH_VARARGS, NULL }, + { (char *)"getVFOOffset", _wrap_getVFOOffset, METH_VARARGS, NULL }, + { (char *)"setVFOOffset", _wrap_setVFOOffset, METH_VARARGS, NULL }, + { (char *)"getIOUDClock", _wrap_getIOUDClock, METH_VARARGS, NULL }, + { (char *)"setIOUDClock", _wrap_setIOUDClock, METH_VARARGS, NULL }, + { (char *)"getDACMult", _wrap_getDACMult, METH_VARARGS, NULL }, + { (char *)"setDACMult", _wrap_setDACMult, METH_VARARGS, NULL }, + { (char *)"getAMP_Relay", _wrap_getAMP_Relay, METH_VARARGS, NULL }, + { (char *)"setAMP_Relay", _wrap_setAMP_Relay, METH_VARARGS, NULL }, + { (char *)"getATTN_Relay", _wrap_getATTN_Relay, METH_VARARGS, NULL }, + { (char *)"setATTN_Relay", _wrap_setATTN_Relay, METH_VARARGS, NULL }, + { (char *)"getXVTR_TR_Relay", _wrap_getXVTR_TR_Relay, METH_VARARGS, NULL }, + { (char *)"setXVTR_TR_Relay", _wrap_setXVTR_TR_Relay, METH_VARARGS, NULL }, + { (char *)"getXVTR_Relay", _wrap_getXVTR_Relay, METH_VARARGS, NULL }, + { (char *)"setXVTR_Relay", _wrap_setXVTR_Relay, METH_VARARGS, NULL }, + { (char *)"getIMPULSE_Relay", _wrap_getIMPULSE_Relay, METH_VARARGS, NULL }, + { (char *)"setIMPULSE_Relay", _wrap_setIMPULSE_Relay, METH_VARARGS, NULL }, + { (char *)"getPA_TransmitRelay", _wrap_getPA_TransmitRelay, METH_VARARGS, NULL }, + { (char *)"setPA_TransmitRelay", _wrap_setPA_TransmitRelay, METH_VARARGS, NULL }, + { (char *)"getPA_BiasOn", _wrap_getPA_BiasOn, METH_VARARGS, NULL }, + { (char *)"setPA_BiasOn", _wrap_setPA_BiasOn, METH_VARARGS, NULL }, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_ushort[] = {{"_p_ushort", 0, "ushort *", 0, 0, 0, 0},{"_p_ushort", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +static swig_type_info _swigt__p_char[] = {{"_p_char", 0, "char *", 0, 0, 0, 0},{"_p_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; +static swig_type_info _swigt__p_u_short[] = {{"_p_u_short", 0, "u_short *", 0, 0, 0, 0},{"_p_u_short", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}}; + +static swig_type_info *swig_types_initial[] = { +_swigt__p_ushort, +_swigt__p_char, +_swigt__p_u_short, +0 +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT(void) SWIG_init(void) { + static PyObject *SWIG_globals = 0; + static int typeinit = 0; + PyObject *m, *d; + int i; + if (!SWIG_globals) SWIG_globals = SWIG_newvarlink(); + m = Py_InitModule((char *) SWIG_name, SwigMethods); + d = PyModule_GetDict(m); + + if (!typeinit) { + for (i = 0; swig_types_initial[i]; i++) { + swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]); + } + typeinit = 1; + } + SWIG_InstallConstants(d,swig_const_table); + + PyDict_SetItemString(d,"FALSE", SWIG_From_int((int)0)); + PyDict_SetItemString(d,"TRUE", SWIG_From_int((int)1)); + PyDict_SetItemString(d,(char*)"cvar", SWIG_globals); + SWIG_addvarlink(SWIG_globals,(char*)"DttSP_SampleRate",_wrap_DttSP_SampleRate_get, _wrap_DttSP_SampleRate_set); + PyDict_SetItemString(d,"IARU1", SWIG_From_int((int)IARU1)); + PyDict_SetItemString(d,"IARU2", SWIG_From_int((int)IARU2)); + PyDict_SetItemString(d,"IARU3", SWIG_From_int((int)IARU3)); + PyDict_SetItemString(d,"BYPASS", SWIG_From_int((int)BYPASS)); + PyDict_SetItemString(d,"MEMORY", SWIG_From_int((int)MEMORY)); + PyDict_SetItemString(d,"FULL", SWIG_From_int((int)FULL)); + PyDict_SetItemString(d,"LAST", SWIG_From_int((int)LAST)); + PyDict_SetItemString(d,"POSITIVE", SWIG_From_int((int)POSITIVE)); + PyDict_SetItemString(d,"NEGATIVE", SWIG_From_int((int)NEGATIVE)); + PyDict_SetItemString(d,"NONE", SWIG_From_int((int)NONE)); + PyDict_SetItemString(d,"bsnone", SWIG_From_int((int)bsnone)); + PyDict_SetItemString(d,"bs0", SWIG_From_int((int)bs0)); + PyDict_SetItemString(d,"bs1", SWIG_From_int((int)bs1)); + PyDict_SetItemString(d,"bs2", SWIG_From_int((int)bs2)); + PyDict_SetItemString(d,"bs3", SWIG_From_int((int)bs3)); + PyDict_SetItemString(d,"bs4", SWIG_From_int((int)bs4)); + PyDict_SetItemString(d,"bs5", SWIG_From_int((int)bs5)); + PyDict_SetItemString(d,"EXT", SWIG_From_int((int)EXT)); + PyDict_SetItemString(d,"BPF", SWIG_From_int((int)BPF)); + PyDict_SetItemString(d,"DAT", SWIG_From_int((int)DAT)); + PyDict_SetItemString(d,"ADR", SWIG_From_int((int)ADR)); + PyDict_SetItemString(d,"PIN_12", SWIG_From_int((int)PIN_12)); + PyDict_SetItemString(d,"Dash", SWIG_From_int((int)Dash)); + PyDict_SetItemString(d,"Dot", SWIG_From_int((int)Dot)); + PyDict_SetItemString(d,"PA_DATA", SWIG_From_int((int)PA_DATA)); + PyDict_SetItemString(d,"PIN_11", SWIG_From_int((int)PIN_11)); + PyDict_SetItemString(d,"P1", SWIG_From_int((int)P1)); + PyDict_SetItemString(d,"P2", SWIG_From_int((int)P2)); + PyDict_SetItemString(d,"P3", SWIG_From_int((int)P3)); + PyDict_SetItemString(d,"P4", SWIG_From_int((int)P4)); + PyDict_SetItemString(d,"P5", SWIG_From_int((int)P5)); + PyDict_SetItemString(d,"P6", SWIG_From_int((int)P6)); + PyDict_SetItemString(d,"P7", SWIG_From_int((int)P7)); + PyDict_SetItemString(d,"SER", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"SCK", SWIG_From_int((int)0x02)); + PyDict_SetItemString(d,"SCLR_NOT", SWIG_From_int((int)0x04)); + PyDict_SetItemString(d,"DCDR_NE", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"IC11", SWIG_From_int((int)IC11)); + PyDict_SetItemString(d,"IC7", SWIG_From_int((int)IC7)); + PyDict_SetItemString(d,"IC9", SWIG_From_int((int)IC9)); + PyDict_SetItemString(d,"IC10", SWIG_From_int((int)IC10)); + PyDict_SetItemString(d,"LPF0", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"LPF1", SWIG_From_int((int)0x02)); + PyDict_SetItemString(d,"LPF2", SWIG_From_int((int)0x04)); + PyDict_SetItemString(d,"LPF3", SWIG_From_int((int)0x08)); + PyDict_SetItemString(d,"LPF4", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"LPF5", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"LPF6", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"LPF7", SWIG_From_int((int)0x80)); + PyDict_SetItemString(d,"LPF8", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"LPF9", SWIG_From_int((int)0x02)); + PyDict_SetItemString(d,"BPF0", SWIG_From_int((int)0x80)); + PyDict_SetItemString(d,"BPF1", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"BPF2", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"BPF3", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"BPF4", SWIG_From_int((int)0x08)); + PyDict_SetItemString(d,"BPF5", SWIG_From_int((int)0x04)); + SWIG_addvarlink(SWIG_globals,(char*)"ic11_memory",_wrap_ic11_memory_get, _wrap_ic11_memory_set); + PyDict_SetItemString(d,"PAF0", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"PAF1", SWIG_From_int((int)0x02)); + PyDict_SetItemString(d,"PAF2", SWIG_From_int((int)0x04)); + PyDict_SetItemString(d,"ADC_CLK", SWIG_From_int((int)0x08)); + PyDict_SetItemString(d,"ADC_DI", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"ADC_CS_NOT", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"PATR", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"ATUCTL", SWIG_From_int((int)0x80)); + SWIG_addvarlink(SWIG_globals,(char*)"ic7_memory",_wrap_ic7_memory_get, _wrap_ic7_memory_set); + PyDict_SetItemString(d,"AMP_RLYS", SWIG_From_int((int)0x03)); + PyDict_SetItemString(d,"XVTR_TR_RLY", SWIG_From_int((int)0x04)); + PyDict_SetItemString(d,"XVTR_RLY", SWIG_From_int((int)0x08)); + PyDict_SetItemString(d,"ATTN_RLY", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"IMPULSE_RLY", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"PA_BIAS_NOT", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"IMPULSE", SWIG_From_int((int)0x80)); + SWIG_addvarlink(SWIG_globals,(char*)"rfe_enabled",_wrap_rfe_enabled_get, _wrap_rfe_enabled_set); + SWIG_addvarlink(SWIG_globals,(char*)"xvtr_enabled",_wrap_xvtr_enabled_get, _wrap_xvtr_enabled_set); + SWIG_addvarlink(SWIG_globals,(char*)"pa_enabled",_wrap_pa_enabled_get, _wrap_pa_enabled_set); + PyDict_SetItemString(d,"PA_LPF_OFF", SWIG_From_int((int)0)); + PyDict_SetItemString(d,"PA_LPF_12_10", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"PA_LPF_17_15", SWIG_From_int((int)0x02)); + PyDict_SetItemString(d,"PA_LPF_30_20", SWIG_From_int((int)0x01+0x02)); + PyDict_SetItemString(d,"PA_LPF_60_40", SWIG_From_int((int)0x04)); + PyDict_SetItemString(d,"PA_LPF_80", SWIG_From_int((int)0x04+0x01)); + PyDict_SetItemString(d,"PA_LPF_160", SWIG_From_int((int)0x04+0x02)); + PyDict_SetItemString(d,"PA_FORWARD_PWR", SWIG_From_int((int)0)); + PyDict_SetItemString(d,"PA_REVERSE_PWR", SWIG_From_int((int)1)); + PyDict_SetItemString(d,"TR", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"MUTE", SWIG_From_int((int)0x80)); + PyDict_SetItemString(d,"GAIN", SWIG_From_int((int)0x80)); + PyDict_SetItemString(d,"WRB", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"RESET", SWIG_From_int((int)0x80)); + SWIG_addvarlink(SWIG_globals,(char*)"band_relay",_wrap_band_relay_get, _wrap_band_relay_set); + SWIG_addvarlink(SWIG_globals,(char*)"external_output",_wrap_external_output_get, _wrap_external_output_set); + SWIG_addvarlink(SWIG_globals,(char*)"mute_relay",_wrap_mute_relay_get, _wrap_mute_relay_set); + SWIG_addvarlink(SWIG_globals,(char*)"transmit_relay",_wrap_transmit_relay_get, _wrap_transmit_relay_set); + SWIG_addvarlink(SWIG_globals,(char*)"gain_relay",_wrap_gain_relay_get, _wrap_gain_relay_set); + SWIG_addvarlink(SWIG_globals,(char*)"latch_delay",_wrap_latch_delay_get, _wrap_latch_delay_set); + PyDict_SetItemString(d,"COMP_PD", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"DIG_PD", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"BYPASS_PLL", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"INT_IOUD", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"OSK_EN", SWIG_From_int((int)0x20)); + PyDict_SetItemString(d,"OSK_INT", SWIG_From_int((int)0x10)); + PyDict_SetItemString(d,"BYPASS_SINC", SWIG_From_int((int)0x40)); + PyDict_SetItemString(d,"PLL_RANGE", SWIG_From_int((int)0x40)); + SWIG_addvarlink(SWIG_globals,(char*)"dds_clock",_wrap_dds_clock_get, _wrap_dds_clock_set); + SWIG_addvarlink(SWIG_globals,(char*)"pll_mult",_wrap_pll_mult_get, _wrap_pll_mult_set); + SWIG_addvarlink(SWIG_globals,(char*)"dds_clock_correction",_wrap_dds_clock_correction_get, _wrap_dds_clock_correction_set); + SWIG_addvarlink(SWIG_globals,(char*)"sysClock",_wrap_sysClock_get, _wrap_sysClock_set); + SWIG_addvarlink(SWIG_globals,(char*)"ioud_clock",_wrap_ioud_clock_get, _wrap_ioud_clock_set); + SWIG_addvarlink(SWIG_globals,(char*)"dac_mult",_wrap_dac_mult_get, _wrap_dac_mult_set); + SWIG_addvarlink(SWIG_globals,(char*)"dds_freq",_wrap_dds_freq_get, _wrap_dds_freq_set); + SWIG_addvarlink(SWIG_globals,(char*)"if_freq",_wrap_if_freq_get, _wrap_if_freq_set); + SWIG_addvarlink(SWIG_globals,(char*)"if_shift",_wrap_if_shift_get, _wrap_if_shift_set); + SWIG_addvarlink(SWIG_globals,(char*)"spur_reduction",_wrap_spur_reduction_get, _wrap_spur_reduction_set); + SWIG_addvarlink(SWIG_globals,(char*)"dds_step_size",_wrap_dds_step_size_get, _wrap_dds_step_size_set); + SWIG_addvarlink(SWIG_globals,(char*)"sample_rate",_wrap_sample_rate_get, _wrap_sample_rate_set); + SWIG_addvarlink(SWIG_globals,(char*)"fft_length",_wrap_fft_length_get, _wrap_fft_length_set); + SWIG_addvarlink(SWIG_globals,(char*)"FFT_Bin_Size",_wrap_FFT_Bin_Size_get, _wrap_FFT_Bin_Size_set); + SWIG_addvarlink(SWIG_globals,(char*)"tune_fft",_wrap_tune_fft_get, _wrap_tune_fft_set); + SWIG_addvarlink(SWIG_globals,(char*)"tune_frac_rel",_wrap_tune_frac_rel_get, _wrap_tune_frac_rel_set); + SWIG_addvarlink(SWIG_globals,(char*)"vfo_offset",_wrap_vfo_offset_get, _wrap_vfo_offset_set); + SWIG_addvarlink(SWIG_globals,(char*)"min_freq",_wrap_min_freq_get, _wrap_min_freq_set); + SWIG_addvarlink(SWIG_globals,(char*)"max_freq",_wrap_max_freq_get, _wrap_max_freq_set); + SWIG_addvarlink(SWIG_globals,(char*)"baseAdr",_wrap_baseAdr_get, _wrap_baseAdr_set); + SWIG_addvarlink(SWIG_globals,(char*)"curBandPlan",_wrap_curBandPlan_get, _wrap_curBandPlan_set); + SWIG_addvarlink(SWIG_globals,(char*)"TWO_TO_THE_48_DIVIDED_BY_200",_wrap_TWO_TO_THE_48_DIVIDED_BY_200_get, _wrap_TWO_TO_THE_48_DIVIDED_BY_200_set); + SWIG_addvarlink(SWIG_globals,(char*)"last_tuning_word",_wrap_last_tuning_word_get, _wrap_last_tuning_word_set); + SWIG_addvarlink(SWIG_globals,(char*)"usb_enabled",_wrap_usb_enabled_get, _wrap_usb_enabled_set); + PyDict_SetItemString(d,"SDR1K_LATCH_EXT", SWIG_From_int((int)0x01)); + PyDict_SetItemString(d,"SDR1K_LATCH_BPF", SWIG_From_int((int)0x02)); +} + diff --git a/pyhw2/hw2.py b/pyhw2/hw2.py new file mode 100644 index 0000000..386e8ae --- /dev/null +++ b/pyhw2/hw2.py @@ -0,0 +1,39 @@ +#/usr/bin/env python + +import sys +from sdr1khw import * + +FALSE = 0 +TRUE = 1 + +openPort("/dev/parport0") +DttSP_SampleRate = 48000.0 + +setRFE_Enabled(TRUE) +ResetRFE() +setXVTR_Enabled(FALSE) +setExtended(FALSE) +setXVTR_TR_Relay(FALSE) +setBandRelay(bs0) + +Init() + +setVFOOffset(0.0) +setATTN_Relay(TRUE) +setTransmitRelay(FALSE) +setGainRelay(TRUE) +setSpurReduction(FALSE) +setExternalOutput(FALSE) +setDDSClockCorrection(0.0) +setDDSFreq(13.845) +setMuteRelay(FALSE) + +print "Ready" + +cmd = sys.stdin.readline() +while not cmd == '': + res = eval(cmd) + print res + cmd = sys.stdin.readline() + +closePort() diff --git a/pyhw2/sdr1k-setup.py b/pyhw2/sdr1k-setup.py new file mode 100644 index 0000000..6e69452 --- /dev/null +++ b/pyhw2/sdr1k-setup.py @@ -0,0 +1,23 @@ +from sdr1khw import * + +openPort("/dev/parport0") +DttSP_SampleRate = 48000.0 + +setRFE_Enabled(TRUE) +ResetRFE() +setXVTR_Enabled(FALSE) +setExtended(FALSE) +setXVTR_TR_Relay(FALSE) +setBandRelay(bs0) + +Init() + +setVFOOffset(0.0) +setATTN_Relay(TRUE) +setTransmitRelay(FALSE) +setGainRelay(TRUE) +setSpurReduction(FALSE) +setExternalOutput(FALSE) +setDDSClockCorrection(0.0) +setDDSFreq(13.845) +setMuteRelay(FALSE) diff --git a/pyhw2/sdr1khw.py b/pyhw2/sdr1khw.py new file mode 100644 index 0000000..3aac512 --- /dev/null +++ b/pyhw2/sdr1khw.py @@ -0,0 +1,330 @@ +# This file was created automatically by SWIG. +# Don't modify this file, modify the SWIG interface instead. +# This file is compatible with both classic and new-style classes. + +import _sdr1khw + +def _swig_setattr(self,class_type,name,value): + if (name == "this"): + if isinstance(value, class_type): + self.__dict__[name] = value.this + if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown + del value.thisown + return + method = class_type.__swig_setmethods__.get(name,None) + if method: return method(self,value) + self.__dict__[name] = value + +def _swig_getattr(self,class_type,name): + method = class_type.__swig_getmethods__.get(name,None) + if method: return method(self) + raise AttributeError,name + +import types +try: + _object = types.ObjectType + _newclass = 1 +except AttributeError: + class _object : pass + _newclass = 0 +del types + + +FALSE = _sdr1khw.FALSE +TRUE = _sdr1khw.TRUE +IARU1 = _sdr1khw.IARU1 +IARU2 = _sdr1khw.IARU2 +IARU3 = _sdr1khw.IARU3 +BYPASS = _sdr1khw.BYPASS +MEMORY = _sdr1khw.MEMORY +FULL = _sdr1khw.FULL +LAST = _sdr1khw.LAST +POSITIVE = _sdr1khw.POSITIVE +NEGATIVE = _sdr1khw.NEGATIVE +NONE = _sdr1khw.NONE +bsnone = _sdr1khw.bsnone +bs0 = _sdr1khw.bs0 +bs1 = _sdr1khw.bs1 +bs2 = _sdr1khw.bs2 +bs3 = _sdr1khw.bs3 +bs4 = _sdr1khw.bs4 +bs5 = _sdr1khw.bs5 +EXT = _sdr1khw.EXT +BPF = _sdr1khw.BPF +DAT = _sdr1khw.DAT +ADR = _sdr1khw.ADR +PIN_12 = _sdr1khw.PIN_12 +Dash = _sdr1khw.Dash +Dot = _sdr1khw.Dot +PA_DATA = _sdr1khw.PA_DATA +PIN_11 = _sdr1khw.PIN_11 +P1 = _sdr1khw.P1 +P2 = _sdr1khw.P2 +P3 = _sdr1khw.P3 +P4 = _sdr1khw.P4 +P5 = _sdr1khw.P5 +P6 = _sdr1khw.P6 +P7 = _sdr1khw.P7 +SER = _sdr1khw.SER +SCK = _sdr1khw.SCK +SCLR_NOT = _sdr1khw.SCLR_NOT +DCDR_NE = _sdr1khw.DCDR_NE +IC11 = _sdr1khw.IC11 +IC7 = _sdr1khw.IC7 +IC9 = _sdr1khw.IC9 +IC10 = _sdr1khw.IC10 +LPF0 = _sdr1khw.LPF0 +LPF1 = _sdr1khw.LPF1 +LPF2 = _sdr1khw.LPF2 +LPF3 = _sdr1khw.LPF3 +LPF4 = _sdr1khw.LPF4 +LPF5 = _sdr1khw.LPF5 +LPF6 = _sdr1khw.LPF6 +LPF7 = _sdr1khw.LPF7 +LPF8 = _sdr1khw.LPF8 +LPF9 = _sdr1khw.LPF9 +BPF0 = _sdr1khw.BPF0 +BPF1 = _sdr1khw.BPF1 +BPF2 = _sdr1khw.BPF2 +BPF3 = _sdr1khw.BPF3 +BPF4 = _sdr1khw.BPF4 +BPF5 = _sdr1khw.BPF5 +PAF0 = _sdr1khw.PAF0 +PAF1 = _sdr1khw.PAF1 +PAF2 = _sdr1khw.PAF2 +ADC_CLK = _sdr1khw.ADC_CLK +ADC_DI = _sdr1khw.ADC_DI +ADC_CS_NOT = _sdr1khw.ADC_CS_NOT +PATR = _sdr1khw.PATR +ATUCTL = _sdr1khw.ATUCTL +AMP_RLYS = _sdr1khw.AMP_RLYS +XVTR_TR_RLY = _sdr1khw.XVTR_TR_RLY +XVTR_RLY = _sdr1khw.XVTR_RLY +ATTN_RLY = _sdr1khw.ATTN_RLY +IMPULSE_RLY = _sdr1khw.IMPULSE_RLY +PA_BIAS_NOT = _sdr1khw.PA_BIAS_NOT +IMPULSE = _sdr1khw.IMPULSE +PA_LPF_OFF = _sdr1khw.PA_LPF_OFF +PA_LPF_12_10 = _sdr1khw.PA_LPF_12_10 +PA_LPF_17_15 = _sdr1khw.PA_LPF_17_15 +PA_LPF_30_20 = _sdr1khw.PA_LPF_30_20 +PA_LPF_60_40 = _sdr1khw.PA_LPF_60_40 +PA_LPF_80 = _sdr1khw.PA_LPF_80 +PA_LPF_160 = _sdr1khw.PA_LPF_160 +PA_FORWARD_PWR = _sdr1khw.PA_FORWARD_PWR +PA_REVERSE_PWR = _sdr1khw.PA_REVERSE_PWR +TR = _sdr1khw.TR +MUTE = _sdr1khw.MUTE +GAIN = _sdr1khw.GAIN +WRB = _sdr1khw.WRB +RESET = _sdr1khw.RESET +COMP_PD = _sdr1khw.COMP_PD +DIG_PD = _sdr1khw.DIG_PD +BYPASS_PLL = _sdr1khw.BYPASS_PLL +INT_IOUD = _sdr1khw.INT_IOUD +OSK_EN = _sdr1khw.OSK_EN +OSK_INT = _sdr1khw.OSK_INT +BYPASS_SINC = _sdr1khw.BYPASS_SINC +PLL_RANGE = _sdr1khw.PLL_RANGE +SDR1K_LATCH_EXT = _sdr1khw.SDR1K_LATCH_EXT +SDR1K_LATCH_BPF = _sdr1khw.SDR1K_LATCH_BPF + +openPort = _sdr1khw.openPort + +closePort = _sdr1khw.closePort + +USB_Sdr1kLatch = _sdr1khw.USB_Sdr1kLatch + +USB_Sdr1kGetStatusPort = _sdr1khw.USB_Sdr1kGetStatusPort + +USB_Sdr1kGetADC = _sdr1khw.USB_Sdr1kGetADC + +USB_Sdr1kDDSReset = _sdr1khw.USB_Sdr1kDDSReset + +USB_Sdr1kDDSWrite = _sdr1khw.USB_Sdr1kDDSWrite + +USB_Sdr1kSRLoad = _sdr1khw.USB_Sdr1kSRLoad + +DttSP_ChangeOsc = _sdr1khw.DttSP_ChangeOsc + +Init = _sdr1khw.Init + +PowerOn = _sdr1khw.PowerOn + +StandBy = _sdr1khw.StandBy + +Impulse = _sdr1khw.Impulse + +StatusPort = _sdr1khw.StatusPort + +SetExt = _sdr1khw.SetExt + +ResExt = _sdr1khw.ResExt + +PinValue = _sdr1khw.PinValue + +SetBPF = _sdr1khw.SetBPF + +TestPort = _sdr1khw.TestPort + +RCKStrobe = _sdr1khw.RCKStrobe + +SRLoad = _sdr1khw.SRLoad + +ResetRFE = _sdr1khw.ResetRFE + +PA_SetLPF = _sdr1khw.PA_SetLPF + +PA_GetADC = _sdr1khw.PA_GetADC + +PA_ATUTune = _sdr1khw.PA_ATUTune + +getEnableLPF0 = _sdr1khw.getEnableLPF0 + +setEnableLPF0 = _sdr1khw.setEnableLPF0 + +getExtended = _sdr1khw.getExtended + +setExtended = _sdr1khw.setExtended + +getX2Enabled = _sdr1khw.getX2Enabled + +setX2Enabled = _sdr1khw.setX2Enabled + +getX2Delay = _sdr1khw.getX2Delay + +setX2Delay = _sdr1khw.setX2Delay + +getRFE_Enabled = _sdr1khw.getRFE_Enabled + +setRFE_Enabled = _sdr1khw.setRFE_Enabled + +getPA_Enabled = _sdr1khw.getPA_Enabled + +setPA_Enabled = _sdr1khw.setPA_Enabled + +getXVTR_Enabled = _sdr1khw.getXVTR_Enabled + +setXVTR_Enabled = _sdr1khw.setXVTR_Enabled + +getUSB_Enabled = _sdr1khw.getUSB_Enabled + +setUSB_Enabled = _sdr1khw.setUSB_Enabled + +getCurrentXVTRTRMode = _sdr1khw.getCurrentXVTRTRMode + +setCurrentXVTRTRMode = _sdr1khw.setCurrentXVTRTRMode + +getLatchDelay = _sdr1khw.getLatchDelay + +setLatchDelay = _sdr1khw.setLatchDelay + +getMinFreq = _sdr1khw.getMinFreq + +getMaxFreq = _sdr1khw.getMaxFreq + +getBaseAddr = _sdr1khw.getBaseAddr + +setBaseAddr = _sdr1khw.setBaseAddr + +getBandRelay = _sdr1khw.getBandRelay + +setBandRelay = _sdr1khw.setBandRelay + +getTransmitRelay = _sdr1khw.getTransmitRelay + +setTransmitRelay = _sdr1khw.setTransmitRelay + +getMuteRelay = _sdr1khw.getMuteRelay + +setMuteRelay = _sdr1khw.setMuteRelay + +getGainRelay = _sdr1khw.getGainRelay + +setGainRelay = _sdr1khw.setGainRelay + +getExternalOutput = _sdr1khw.getExternalOutput + +setExternalOutput = _sdr1khw.setExternalOutput + +getDDSClockCorrection = _sdr1khw.getDDSClockCorrection + +setDDSClockCorrection = _sdr1khw.setDDSClockCorrection + +getPLLMult = _sdr1khw.getPLLMult + +setPLLMult = _sdr1khw.setPLLMult + +getDDSClock = _sdr1khw.getDDSClock + +setDDSClock = _sdr1khw.setDDSClock + +getIFShift = _sdr1khw.getIFShift + +setIFShift = _sdr1khw.setIFShift + +getSpurReduction = _sdr1khw.getSpurReduction + +setSpurReduction = _sdr1khw.setSpurReduction + +getIFFreq = _sdr1khw.getIFFreq + +setIFFreq = _sdr1khw.setIFFreq + +getDDSFreq = _sdr1khw.getDDSFreq + +setDDSFreq = _sdr1khw.setDDSFreq + +getSampleRate = _sdr1khw.getSampleRate + +setSampleRate = _sdr1khw.setSampleRate + +getFFTLength = _sdr1khw.getFFTLength + +setFFTLength = _sdr1khw.setFFTLength + +getTuneFFT = _sdr1khw.getTuneFFT + +getTuneFracRel = _sdr1khw.getTuneFracRel + +getVFOOffset = _sdr1khw.getVFOOffset + +setVFOOffset = _sdr1khw.setVFOOffset + +getIOUDClock = _sdr1khw.getIOUDClock + +setIOUDClock = _sdr1khw.setIOUDClock + +getDACMult = _sdr1khw.getDACMult + +setDACMult = _sdr1khw.setDACMult + +getAMP_Relay = _sdr1khw.getAMP_Relay + +setAMP_Relay = _sdr1khw.setAMP_Relay + +getATTN_Relay = _sdr1khw.getATTN_Relay + +setATTN_Relay = _sdr1khw.setATTN_Relay + +getXVTR_TR_Relay = _sdr1khw.getXVTR_TR_Relay + +setXVTR_TR_Relay = _sdr1khw.setXVTR_TR_Relay + +getXVTR_Relay = _sdr1khw.getXVTR_Relay + +setXVTR_Relay = _sdr1khw.setXVTR_Relay + +getIMPULSE_Relay = _sdr1khw.getIMPULSE_Relay + +setIMPULSE_Relay = _sdr1khw.setIMPULSE_Relay + +getPA_TransmitRelay = _sdr1khw.getPA_TransmitRelay + +setPA_TransmitRelay = _sdr1khw.setPA_TransmitRelay + +getPA_BiasOn = _sdr1khw.getPA_BiasOn + +setPA_BiasOn = _sdr1khw.setPA_BiasOn +cvar = _sdr1khw.cvar + -- 2.45.2