--- /dev/null
+// 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;
+}
--- /dev/null
+/* ----------------------------------------------------------------------------
+ * 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));
+}
+
projects / dttsp.git / commitdiff