]> git.rkrishnan.org Git - dttsp.git/blob - pyhw2/hardware_wrap.c
New hardware control code
[dttsp.git] / pyhw2 / hardware_wrap.c
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 1.3.22
4  * 
5  * This file is not intended to be easily readable and contains a number of 
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG 
8  * interface file instead. 
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #include "Python.h"
14
15 /*************************************************************** -*- c -*-
16  * python/precommon.swg
17  *
18  * Rename all exported symbols from common.swg, to avoid symbol
19  * clashes if multiple interpreters are included
20  *
21  ************************************************************************/
22
23 #define SWIG_TypeRegister    SWIG_Python_TypeRegister
24 #define SWIG_TypeCheck       SWIG_Python_TypeCheck
25 #define SWIG_TypeCast        SWIG_Python_TypeCast
26 #define SWIG_TypeDynamicCast SWIG_Python_TypeDynamicCast
27 #define SWIG_TypeName        SWIG_Python_TypeName
28 #define SWIG_TypePrettyName  SWIG_Python_TypePrettyName
29 #define SWIG_TypeQuery       SWIG_Python_TypeQuery
30 #define SWIG_TypeClientData  SWIG_Python_TypeClientData
31 #define SWIG_PackData        SWIG_Python_PackData 
32 #define SWIG_UnpackData      SWIG_Python_UnpackData 
33
34
35 /***********************************************************************
36  * common.swg
37  *
38  *     This file contains generic SWIG runtime support for pointer
39  *     type checking as well as a few commonly used macros to control
40  *     external linkage.
41  *
42  * Author : David Beazley (beazley@cs.uchicago.edu)
43  *
44  * Copyright (c) 1999-2000, The University of Chicago
45  * 
46  * This file may be freely redistributed without license or fee provided
47  * this copyright message remains intact.
48  ************************************************************************/
49
50 #include <string.h>
51
52 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
53 #  if defined(_MSC_VER) || defined(__GNUC__)
54 #    if defined(STATIC_LINKED)
55 #      define SWIGEXPORT(a) a
56 #      define SWIGIMPORT(a) extern a
57 #    else
58 #      define SWIGEXPORT(a) __declspec(dllexport) a
59 #      define SWIGIMPORT(a) extern a
60 #    endif
61 #  else
62 #    if defined(__BORLANDC__)
63 #      define SWIGEXPORT(a) a _export
64 #      define SWIGIMPORT(a) a _export
65 #    else
66 #      define SWIGEXPORT(a) a
67 #      define SWIGIMPORT(a) a
68 #    endif
69 #  endif
70 #else
71 #  define SWIGEXPORT(a) a
72 #  define SWIGIMPORT(a) a
73 #endif
74
75 #ifdef SWIG_GLOBAL
76 #  define SWIGRUNTIME(a) SWIGEXPORT(a)
77 #else
78 #  define SWIGRUNTIME(a) static a
79 #endif
80
81 #ifdef __cplusplus
82 extern "C" {
83 #endif
84
85 typedef void *(*swig_converter_func)(void *);
86 typedef struct swig_type_info *(*swig_dycast_func)(void **);
87
88 typedef struct swig_type_info {
89   const char             *name;
90   swig_converter_func     converter;
91   const char             *str;
92   void                   *clientdata;
93   swig_dycast_func        dcast;
94   struct swig_type_info  *next;
95   struct swig_type_info  *prev;
96 } swig_type_info;
97
98 #ifdef SWIG_NOINCLUDE
99
100 SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
101 SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
102 SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
103 SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
104 SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
105 SWIGIMPORT(const char *)     SWIG_TypePrettyName(const swig_type_info *);
106 SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
107 SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
108 SWIGIMPORT(char *)           SWIG_PackData(char *, void *, int);
109 SWIGIMPORT(char *)           SWIG_UnpackData(char *, void *, int);
110
111 #else
112
113 static swig_type_info *swig_type_list = 0;
114 static swig_type_info **swig_type_list_handle = &swig_type_list;
115
116 /* Register a type mapping with the type-checking */
117 SWIGRUNTIME(swig_type_info *)
118 SWIG_TypeRegister(swig_type_info *ti) {
119   swig_type_info *tc, *head, *ret, *next;
120   /* Check to see if this type has already been registered */
121   tc = *swig_type_list_handle;
122   while (tc) {
123     if (strcmp(tc->name, ti->name) == 0) {
124       /* Already exists in the table.  Just add additional types to the list */
125       if (tc->clientdata) ti->clientdata = tc->clientdata;
126       head = tc;
127       next = tc->next;
128       goto l1;
129     }
130     tc = tc->prev;
131   }
132   head = ti;
133   next = 0;
134
135   /* Place in list */
136   ti->prev = *swig_type_list_handle;
137   *swig_type_list_handle = ti;
138
139   /* Build linked lists */
140   l1:
141   ret = head;
142   tc = ti + 1;
143   /* Patch up the rest of the links */
144   while (tc->name) {
145     head->next = tc;
146     tc->prev = head;
147     head = tc;
148     tc++;
149   }
150   if (next) next->prev = head;
151   head->next = next;
152   return ret;
153 }
154
155 /* Check the typename */
156 SWIGRUNTIME(swig_type_info *) 
157 SWIG_TypeCheck(char *c, swig_type_info *ty) {
158   swig_type_info *s;
159   if (!ty) return 0;        /* Void pointer */
160   s = ty->next;             /* First element always just a name */
161   do {
162     if (strcmp(s->name,c) == 0) {
163       if (s == ty->next) return s;
164       /* Move s to the top of the linked list */
165       s->prev->next = s->next;
166       if (s->next) {
167         s->next->prev = s->prev;
168       }
169       /* Insert s as second element in the list */
170       s->next = ty->next;
171       if (ty->next) ty->next->prev = s;
172       ty->next = s;
173       s->prev = ty;
174       return s;
175     }
176     s = s->next;
177   } while (s && (s != ty->next));
178   return 0;
179 }
180
181 /* Cast a pointer up an inheritance hierarchy */
182 SWIGRUNTIME(void *) 
183 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
184   if ((!ty) || (!ty->converter)) return ptr;
185   return (*ty->converter)(ptr);
186 }
187
188 /* Dynamic pointer casting. Down an inheritance hierarchy */
189 SWIGRUNTIME(swig_type_info *) 
190 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
191   swig_type_info *lastty = ty;
192   if (!ty || !ty->dcast) return ty;
193   while (ty && (ty->dcast)) {
194     ty = (*ty->dcast)(ptr);
195     if (ty) lastty = ty;
196   }
197   return lastty;
198 }
199
200 /* Return the name associated with this type */
201 SWIGRUNTIME(const char *)
202 SWIG_TypeName(const swig_type_info *ty) {
203   return ty->name;
204 }
205
206 /* Return the pretty name associated with this type,
207    that is an unmangled type name in a form presentable to the user.
208 */
209 SWIGRUNTIME(const char *)
210 SWIG_TypePrettyName(const swig_type_info *type) {
211   /* The "str" field contains the equivalent pretty names of the
212      type, separated by vertical-bar characters.  We choose
213      to print the last name, as it is often (?) the most
214      specific. */
215   if (type->str != NULL) {
216     const char *last_name = type->str;
217     const char *s;
218     for (s = type->str; *s; s++)
219       if (*s == '|') last_name = s+1;
220     return last_name;
221   }
222   else
223     return type->name;
224 }
225
226 /* 
227    Compare two type names skipping the space characters, therefore
228    "char*" == "char *" and "Class<int>" == "Class<int >", etc.
229
230    Return 0 when the two name types are equivalent, as in
231    strncmp, but skipping ' '.
232 */
233 static int
234 SWIG_TypeNameComp(const char *f1, const char *l1,
235                   const char *f2, const char *l2) {
236   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
237     while ((*f1 == ' ') && (f1 != l1)) ++f1;
238     while ((*f2 == ' ') && (f2 != l2)) ++f2;
239     if (*f1 != *f2) return *f1 - *f2;
240   }
241   return (l1 - f1) - (l2 - f2);
242 }
243
244 /*
245   Check type equivalence in a name list like <name1>|<name2>|...
246 */
247 static int
248 SWIG_TypeEquiv(const char *nb, const char *tb) {
249   int equiv = 0;
250   const char* te = tb + strlen(tb);
251   const char* ne = nb;
252   while (!equiv && *ne) {
253     for (nb = ne; *ne; ++ne) {
254       if (*ne == '|') break;
255     }
256     equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
257     if (*ne) ++ne;
258   }
259   return equiv;
260 }
261   
262
263 /* Search for a swig_type_info structure */
264 SWIGRUNTIME(swig_type_info *)
265 SWIG_TypeQuery(const char *name) {
266   swig_type_info *ty = *swig_type_list_handle;
267   while (ty) {
268     if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
269     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
270     ty = ty->prev;
271   }
272   return 0;
273 }
274
275 /* Set the clientdata field for a type */
276 SWIGRUNTIME(void)
277 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
278   swig_type_info *tc, *equiv;
279   if (ti->clientdata == clientdata) return;
280   ti->clientdata = clientdata;
281   equiv = ti->next;
282   while (equiv) {
283     if (!equiv->converter) {
284       tc = *swig_type_list_handle;
285       while (tc) {
286         if ((strcmp(tc->name, equiv->name) == 0))
287           SWIG_TypeClientData(tc,clientdata);
288         tc = tc->prev;
289       }
290     }
291     equiv = equiv->next;
292   }
293 }
294
295 /* Pack binary data into a string */
296 SWIGRUNTIME(char *)
297 SWIG_PackData(char *c, void *ptr, int sz) {
298   static char hex[17] = "0123456789abcdef";
299   unsigned char *u = (unsigned char *) ptr;
300   const unsigned char *eu =  u + sz;
301   register unsigned char uu;
302   for (; u != eu; ++u) {
303     uu = *u;
304     *(c++) = hex[(uu & 0xf0) >> 4];
305     *(c++) = hex[uu & 0xf];
306   }
307   return c;
308 }
309
310 /* Unpack binary data from a string */
311 SWIGRUNTIME(char *)
312 SWIG_UnpackData(char *c, void *ptr, int sz) {
313   register unsigned char uu = 0;
314   register int d;
315   unsigned char *u = (unsigned char *) ptr;
316   const unsigned char *eu =  u + sz;
317   for (; u != eu; ++u) {
318     d = *(c++);
319     if ((d >= '0') && (d <= '9'))
320       uu = ((d - '0') << 4);
321     else if ((d >= 'a') && (d <= 'f'))
322       uu = ((d - ('a'-10)) << 4);
323     d = *(c++);
324     if ((d >= '0') && (d <= '9'))
325       uu |= (d - '0');
326     else if ((d >= 'a') && (d <= 'f'))
327       uu |= (d - ('a'-10));
328     *u = uu;
329   }
330   return c;
331 }
332
333 #endif
334
335 #ifdef __cplusplus
336 }
337 #endif
338
339 /***********************************************************************
340  * pyrun.swg
341  *
342  *     This file contains the runtime support for Python modules
343  *     and includes code for managing global variables and pointer
344  *     type checking.
345  *
346  * Author : David Beazley (beazley@cs.uchicago.edu)
347  ************************************************************************/
348
349 #ifdef __cplusplus
350 extern "C" {
351 #endif
352
353 #define SWIG_PY_INT     1
354 #define SWIG_PY_FLOAT   2
355 #define SWIG_PY_STRING  3
356 #define SWIG_PY_POINTER 4
357 #define SWIG_PY_BINARY  5
358
359 /* Flags for pointer conversion */
360
361 #define SWIG_POINTER_EXCEPTION     0x1
362 #define SWIG_POINTER_DISOWN        0x2
363
364 /* Exception handling in wrappers */
365 #define SWIG_fail   goto fail
366
367 /* Constant information structure */
368 typedef struct swig_const_info {
369     int type;
370     char *name;
371     long lvalue;
372     double dvalue;
373     void   *pvalue;
374     swig_type_info **ptype;
375 } swig_const_info;
376
377 /* Common SWIG API */
378 #define SWIG_ConvertPtr(obj, pp, type, flags) \
379   SWIG_Python_ConvertPtr(obj, pp, type, flags)
380 #define SWIG_NewPointerObj(p, type, flags) \
381   SWIG_Python_NewPointerObj(p, type, flags)
382 #define SWIG_MustGetPtr(p, type, argnum, flags) \
383   SWIG_Python_MustGetPtr(p, type, argnum, flags)
384  
385 /* Python-specific SWIG API */
386 #define SWIG_newvarlink() \
387   SWIG_Python_newvarlink()
388 #define SWIG_addvarlink(p, name, get_attr, set_attr) \
389   SWIG_Python_addvarlink(p, name, get_attr, set_attr)
390 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
391   SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
392 #define SWIG_NewPackedObj(ptr, sz, type) \
393   SWIG_Python_NewPackedObj(ptr, sz, type)
394 #define SWIG_InstallConstants(d, constants) \
395   SWIG_Python_InstallConstants(d, constants)
396
397 typedef double (*py_objasdbl_conv)(PyObject *obj);
398
399 #ifdef SWIG_NOINCLUDE
400
401 SWIGIMPORT(int)               SWIG_Python_ConvertPtr(PyObject *, void **, swig_type_info *, int);
402 SWIGIMPORT(PyObject *)        SWIG_Python_NewPointerObj(void *, swig_type_info *,int own);
403 SWIGIMPORT(void *)            SWIG_Python_MustGetPtr(PyObject *, swig_type_info *, int, int);
404 SWIGIMPORT(PyObject *)        SWIG_Python_newvarlink(void);
405 SWIGIMPORT(void)              SWIG_Python_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
406 SWIGIMPORT(int)               SWIG_Python_ConvertPacked(PyObject *, void *, int sz, swig_type_info *, int);
407 SWIGIMPORT(PyObject *)        SWIG_Python_NewPackedObj(void *, int sz, swig_type_info *);
408 SWIGIMPORT(void)              SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]);
409
410
411 #else
412
413
414 /* -----------------------------------------------------------------------------
415  * global variable support code.
416  * ----------------------------------------------------------------------------- */
417
418 typedef struct swig_globalvar {   
419   char       *name;                  /* Name of global variable */
420   PyObject *(*get_attr)(void);       /* Return the current value */
421   int       (*set_attr)(PyObject *); /* Set the value */
422   struct swig_globalvar *next;
423 } swig_globalvar;
424
425 typedef struct swig_varlinkobject {
426   PyObject_HEAD
427   swig_globalvar *vars;
428 } swig_varlinkobject;
429
430 static PyObject *
431 swig_varlink_repr(swig_varlinkobject *v) {
432   v = v;
433   return PyString_FromString("<Global variables>");
434 }
435
436 static int
437 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
438   swig_globalvar  *var;
439   flags = flags;
440   fprintf(fp,"Global variables { ");
441   for (var = v->vars; var; var=var->next) {
442     fprintf(fp,"%s", var->name);
443     if (var->next) fprintf(fp,", ");
444   }
445   fprintf(fp," }\n");
446   return 0;
447 }
448
449 static PyObject *
450 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
451   swig_globalvar *var = v->vars;
452   while (var) {
453     if (strcmp(var->name,n) == 0) {
454       return (*var->get_attr)();
455     }
456     var = var->next;
457   }
458   PyErr_SetString(PyExc_NameError,"Unknown C global variable");
459   return NULL;
460 }
461
462 static int
463 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
464   swig_globalvar *var = v->vars;
465   while (var) {
466     if (strcmp(var->name,n) == 0) {
467       return (*var->set_attr)(p);
468     }
469     var = var->next;
470   }
471   PyErr_SetString(PyExc_NameError,"Unknown C global variable");
472   return 1;
473 }
474
475 statichere PyTypeObject varlinktype = {
476   PyObject_HEAD_INIT(0)              
477   0,                                  /* Number of items in variable part (ob_size) */
478   (char *)"swigvarlink",              /* Type name (tp_name) */
479   sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
480   0,                                  /* Itemsize (tp_itemsize) */
481   0,                                  /* Deallocator (tp_dealloc) */ 
482   (printfunc) swig_varlink_print,     /* Print (tp_print) */
483   (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
484   (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
485   0,                                  /* tp_compare */
486   (reprfunc) swig_varlink_repr,       /* tp_repr */
487   0,                                  /* tp_as_number */
488   0,                                  /* tp_as_sequence */
489   0,                                  /* tp_as_mapping */
490   0,                                  /* tp_hash */
491   0,                                  /* tp_call */
492   0,                                  /* tp_str */
493   0,                                  /* tp_getattro */
494   0,                                  /* tp_setattro */
495   0,                                  /* tp_as_buffer */
496   0,                                  /* tp_flags */
497   0,                                  /* tp_doc */
498   0,                                  /* tp_traverse */
499   0,                                  /* tp_clear */
500   0,                                  /* tp_richcompare */
501   0,                                  /* tp_weaklistoffset */
502 #if PY_VERSION_HEX >= 0x02020000
503   0,                                  /* tp_iter */
504   0,                                  /* tp_iternext */
505   0,                                  /* tp_methods */
506   0,                                  /* tp_members */
507   0,                                  /* tp_getset */
508   0,                                  /* tp_base */
509   0,                                  /* tp_dict */
510   0,                                  /* tp_descr_get */
511   0,                                  /* tp_descr_set */
512   0,                                  /* tp_dictoffset */
513   0,                                  /* tp_init */
514   0,                                  /* tp_alloc */
515   0,                                  /* tp_new */
516   0,                                  /* tp_free */
517   0,                                  /* tp_is_gc */
518   0,                                  /* tp_bases */
519   0,                                  /* tp_mro */
520   0,                                  /* tp_cache */
521   0,                                  /* tp_subclasses */
522   0,                                  /* tp_weaklist */
523 #endif
524 #if PY_VERSION_HEX >= 0x02030200
525   0,                                  /* tp_del */
526 #endif
527 #ifdef COUNT_ALLOCS
528   /* these must be last */
529   0,                                  /* tp_alloc */
530   0,                                  /* tp_free */
531   0,                                  /* tp_maxalloc */
532   0,                                  /*  tp_next */
533 #endif
534 };
535
536 /* Create a variable linking object for use later */
537 SWIGRUNTIME(PyObject *)
538 SWIG_Python_newvarlink(void) {
539   swig_varlinkobject *result = 0;
540   result = PyMem_NEW(swig_varlinkobject,1);
541   varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
542   result->ob_type = &varlinktype;
543   result->vars = 0;
544   result->ob_refcnt = 0;
545   Py_XINCREF((PyObject *) result);
546   return ((PyObject*) result);
547 }
548
549 SWIGRUNTIME(void)
550 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
551   swig_varlinkobject *v;
552   swig_globalvar *gv;
553   v= (swig_varlinkobject *) p;
554   gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
555   gv->name = (char *) malloc(strlen(name)+1);
556   strcpy(gv->name,name);
557   gv->get_attr = get_attr;
558   gv->set_attr = set_attr;
559   gv->next = v->vars;
560   v->vars = gv;
561 }
562
563 /* Convert a pointer value */
564 SWIGRUNTIME(int)
565 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
566   swig_type_info *tc;
567   char  *c = 0;
568   static PyObject *SWIG_this = 0;
569   int    newref = 0;
570   PyObject  *pyobj = 0;
571
572   if (!obj) return 0;
573   if (obj == Py_None) {
574     *ptr = 0;
575     return 0;
576   }
577 #ifdef SWIG_COBJECT_TYPES
578   if (!(PyCObject_Check(obj))) {
579     if (!SWIG_this)
580       SWIG_this = PyString_FromString("this");
581     pyobj = obj;
582     obj = PyObject_GetAttr(obj,SWIG_this);
583     newref = 1;
584     if (!obj) goto type_error;
585     if (!PyCObject_Check(obj)) {
586       Py_DECREF(obj);
587       goto type_error;
588     }
589   }  
590   *ptr = PyCObject_AsVoidPtr(obj);
591   c = (char *) PyCObject_GetDesc(obj);
592   if (newref) Py_DECREF(obj);
593   goto cobject;
594 #else
595   if (!(PyString_Check(obj))) {
596     if (!SWIG_this)
597       SWIG_this = PyString_FromString("this");
598     pyobj = obj;
599     obj = PyObject_GetAttr(obj,SWIG_this);
600     newref = 1;
601     if (!obj) goto type_error;
602     if (!PyString_Check(obj)) {
603       Py_DECREF(obj);
604       goto type_error;
605     }
606   } 
607   c = PyString_AS_STRING(obj);
608   /* Pointer values must start with leading underscore */
609   if (*c != '_') {
610     *ptr = (void *) 0;
611     if (strcmp(c,"NULL") == 0) {
612       if (newref) { Py_DECREF(obj); }
613       return 0;
614     } else {
615       if (newref) { Py_DECREF(obj); }
616       goto type_error;
617     }
618   }
619   c++;
620   c = SWIG_UnpackData(c,ptr,sizeof(void *));
621   if (newref) { Py_DECREF(obj); }
622 #endif
623
624 #ifdef SWIG_COBJECT_TYPES
625 cobject:
626 #endif
627
628   if (ty) {
629     tc = SWIG_TypeCheck(c,ty);
630     if (!tc) goto type_error;
631     *ptr = SWIG_TypeCast(tc,(void*) *ptr);
632   }
633
634   if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
635     PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
636   }
637   return 0;
638
639 type_error:
640   PyErr_Clear();
641   if (flags & SWIG_POINTER_EXCEPTION) {
642     if (ty && c) {
643       PyErr_Format(PyExc_TypeError, 
644                    "Type error. Got %s, expected %s",
645                    c, ty->name);
646     } else {
647       PyErr_SetString(PyExc_TypeError,"Expected a pointer");
648     }
649   }
650   return -1;
651 }
652
653 /* Convert a pointer value, signal an exception on a type mismatch */
654 SWIGRUNTIME(void *)
655 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
656   void *result;
657   SWIG_Python_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
658   return result;
659 }
660
661 /* Convert a packed value value */
662 SWIGRUNTIME(int)
663 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, int sz, swig_type_info *ty, int flags) {
664   swig_type_info *tc;
665   char  *c = 0;
666
667   if ((!obj) || (!PyString_Check(obj))) goto type_error;
668   c = PyString_AS_STRING(obj);
669   /* Pointer values must start with leading underscore */
670   if (*c != '_') goto type_error;
671   c++;
672   c = SWIG_UnpackData(c,ptr,sz);
673   if (ty) {
674     tc = SWIG_TypeCheck(c,ty);
675     if (!tc) goto type_error;
676   }
677   return 0;
678
679 type_error:
680
681   if (flags) {
682     if (ty && c) {
683       PyErr_Format(PyExc_TypeError, 
684                    "Type error. Got %s, expected %s",
685                    c, ty->name);
686     } else {
687       PyErr_SetString(PyExc_TypeError,"Expected a pointer");
688     }
689   }
690   return -1;
691 }
692
693 /* Create a new pointer object */
694 SWIGRUNTIME(PyObject *)
695 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
696   PyObject *robj;
697   if (!ptr) {
698     Py_INCREF(Py_None);
699     return Py_None;
700   }
701 #ifdef SWIG_COBJECT_TYPES
702   robj = PyCObject_FromVoidPtrAndDesc((void *) ptr, (char *) type->name, NULL);
703 #else
704   {
705     char result[1024];
706     char *r = result;
707     *(r++) = '_';
708     r = SWIG_PackData(r,&ptr,sizeof(void *));
709     strcpy(r,type->name);
710     robj = PyString_FromString(result);
711   }
712 #endif
713   if (!robj || (robj == Py_None)) return robj;
714   if (type->clientdata) {
715     PyObject *inst;
716     PyObject *args = Py_BuildValue((char*)"(O)", robj);
717     Py_DECREF(robj);
718     inst = PyObject_CallObject((PyObject *) type->clientdata, args);
719     Py_DECREF(args);
720     if (inst) {
721       if (own) {
722         PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
723       }
724       robj = inst;
725     }
726   }
727   return robj;
728 }
729
730 SWIGRUNTIME(PyObject *)
731 SWIG_Python_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
732   char result[1024];
733   char *r = result;
734   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
735   *(r++) = '_';
736   r = SWIG_PackData(r,ptr,sz);
737   strcpy(r,type->name);
738   return PyString_FromString(result);
739 }
740
741 /* Install Constants */
742 SWIGRUNTIME(void)
743 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
744   int i;
745   PyObject *obj;
746   for (i = 0; constants[i].type; i++) {
747     switch(constants[i].type) {
748     case SWIG_PY_INT:
749       obj = PyInt_FromLong(constants[i].lvalue);
750       break;
751     case SWIG_PY_FLOAT:
752       obj = PyFloat_FromDouble(constants[i].dvalue);
753       break;
754     case SWIG_PY_STRING:
755       if (constants[i].pvalue) {
756         obj = PyString_FromString((char *) constants[i].pvalue);
757       } else {
758         Py_INCREF(Py_None);
759         obj = Py_None;
760       }
761       break;
762     case SWIG_PY_POINTER:
763       obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
764       break;
765     case SWIG_PY_BINARY:
766       obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
767       break;
768     default:
769       obj = 0;
770       break;
771     }
772     if (obj) {
773       PyDict_SetItemString(d,constants[i].name,obj);
774       Py_DECREF(obj);
775     }
776   }
777 }
778
779 #endif
780
781 /* Contract support */
782
783 #define SWIG_contract_assert(expr, msg) if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
784
785 #ifdef __cplusplus
786 }
787 #endif
788
789
790 /* -------- TYPES TABLE (BEGIN) -------- */
791
792 #define  SWIGTYPE_p_ushort swig_types[0] 
793 #define  SWIGTYPE_p_char swig_types[1] 
794 #define  SWIGTYPE_p_u_short swig_types[2] 
795 static swig_type_info *swig_types[4];
796
797 /* -------- TYPES TABLE (END) -------- */
798
799
800 /*-----------------------------------------------
801               @(target):= _sdr1khw.so
802   ------------------------------------------------*/
803 #define SWIG_init    init_sdr1khw
804
805 #define SWIG_name    "_sdr1khw"
806
807 /* Auxiliar swig  macros that appear in the header */
808
809 #define SWIG_OLDOBJ  1
810 #define SWIG_NEWOBJ  SWIG_OLDOBJ + 1
811 #define SWIG_PYSTR   SWIG_NEWOBJ + 1
812
813 #ifdef __cplusplus
814 #define SWIGSTATICINLINE(a) static inline a
815 #define SWIGSTATIC(a) static a
816 #define swig_new_array(size,Type) (new Type[(size)])
817 #define swig_delete(cptr) delete cptr
818 #define swig_delete_array(cptr) delete[] cptr
819 #define swig_const_cast(a,Type) const_cast<Type >(a)
820 #define swig_static_cast(a,Type) static_cast<Type >(a)
821 #define swig_reinterpret_cast(a,Type) reinterpret_cast<Type >(a)
822 #define swig_new_copy(ptr,Type) (new Type(*ptr))
823 #define swig_numeric_cast(a,Type) static_cast<Type >(a)
824
825 #else /* C case */
826
827 #define SWIGSTATICINLINE(a) static a
828 #define SWIGSTATIC(a) static a
829 #define swig_new_array(size,Type) ((Type*) malloc((size)*sizeof(Type)))
830 #define swig_delete(cptr) free((char*)cptr)
831 #define swig_delete_array(cptr) free((char*)cptr)
832 #define swig_const_cast(a,Type) (Type)(a)
833 #define swig_static_cast(a,Type) (Type)(a)
834 #define swig_reinterpret_cast(a,Type) (Type)(a)
835 #define swig_numeric_cast(a,Type) (Type)(a)
836 #define swig_new_copy(ptr,Type)  ((Type*)memcpy(malloc(sizeof(Type)),ptr,sizeof(Type)))
837
838 #endif /* __cplusplus */
839
840
841 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
842 #define SWIG_From_signed_SS_char PyInt_FromLong
843 /*@@*/
844 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
845 #define SWIG_From_unsigned_SS_char PyInt_FromLong
846 /*@@*/
847 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
848 #define SWIG_From_short PyInt_FromLong
849 /*@@*/
850 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
851 #define SWIG_From_unsigned_SS_short PyInt_FromLong
852 /*@@*/
853 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
854 #define SWIG_From_int PyInt_FromLong
855 /*@@*/
856 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
857 #define SWIG_From_long PyInt_FromLong
858 /*@@*/
859 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
860 #define SWIG_From_float PyFloat_FromDouble
861 /*@@*/
862 /*@/usr/local/share/swig/1.3.22/python/pymacros.swg,63,SWIG_define@*/
863 #define SWIG_From_double PyFloat_FromDouble
864 /*@@*/
865
866
867 #include "hardware.h"
868
869 extern double DttSP_SampleRate;
870
871 SWIGSTATICINLINE(int)
872   SWIG_AsVal_double(PyObject *obj, double *val)
873 {
874   if (PyFloat_Check(obj)) {
875     if (val) *val = PyFloat_AS_DOUBLE(obj);
876     return 1;
877   }  
878   if (PyInt_Check(obj)) {
879     if (val) *val = PyInt_AS_LONG(obj);
880     return 1;
881   }
882   if (PyLong_Check(obj)) {
883     double v = PyLong_AsDouble(obj);
884     if (!PyErr_Occurred()) {
885       if (val) *val = v;
886       return 1;
887     } else {
888       if (!val) PyErr_Clear();
889       return 0;
890     }
891   }
892   if (val) {
893     PyErr_SetString(PyExc_TypeError, "a double is expected");
894   }
895   return 0;
896 }
897
898
899 SWIGSTATICINLINE(double)
900 SWIG_As_double(PyObject* obj)
901 {
902   double v;
903   if (!SWIG_AsVal_double(obj, &v)) {
904     /*
905       this is needed to make valgrind/purify happier.  the other
906       solution is throw an exception, but since this code should work
907       with plain C ....
908      */
909     memset((void*)&v, 0, sizeof(double));
910   }
911   return v;
912 }
913
914 extern int ic11_memory;
915
916 #include <limits.h>
917
918
919 SWIGSTATICINLINE(int)
920   SWIG_CheckLongInRange(long value, long min_value, long max_value,
921                         const char *errmsg)
922 {
923   if (value < min_value) {
924     if (errmsg) {
925       PyErr_Format(PyExc_OverflowError, 
926                    "value %ld is less than '%s' minimum %ld", 
927                    value, errmsg, min_value);
928     }
929     return 0;    
930   } else if (value > max_value) {
931     if (errmsg) {
932       PyErr_Format(PyExc_OverflowError,
933                    "value %ld is greater than '%s' maximum %ld", 
934                    value, errmsg, max_value);
935     }
936     return 0;
937   }
938   return 1;
939 }
940
941
942 SWIGSTATICINLINE(int)
943   SWIG_AsVal_long(PyObject * obj, long* val)
944 {
945   if (PyInt_Check(obj)) {
946     if (val) *val = PyInt_AS_LONG(obj);
947     return 1;
948   }
949   if (PyLong_Check(obj)) {
950     long v = PyLong_AsLong(obj);
951     if (!PyErr_Occurred()) {
952       if (val) *val = v;
953       return 1;
954     } else {
955       if (!val) PyErr_Clear();
956       return 0;
957     }
958   }
959   if (val) {
960     PyErr_SetString(PyExc_TypeError, "a long is expected");
961   }
962   return 0;
963  }
964
965
966 #if INT_MAX != LONG_MAX
967 SWIGSTATICINLINE(int)
968   SWIG_AsVal_int(PyObject *obj, int *val)
969
970   const char* errmsg = val ? "int" : 0;
971   long v;
972   if (SWIG_AsVal_long(obj, &v)) {
973     if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
974       if (val) *val = swig_numeric_cast(v, int);
975       return 1;
976     } else {
977       return 0;
978     }
979   } else {
980     PyErr_Clear();
981   }
982   if (val) {
983     PyErr_SetString(PyExc_TypeError, "an int is expected");
984   }
985   return 0;    
986 }
987 #else
988 SWIGSTATICINLINE(int)
989   SWIG_AsVal_int(PyObject *obj, int *val)
990 {
991   return SWIG_AsVal_long(obj,(long*)val);
992 }
993 #endif
994
995
996 SWIGSTATICINLINE(int)
997 SWIG_As_int(PyObject* obj)
998 {
999   int v;
1000   if (!SWIG_AsVal_int(obj, &v)) {
1001     /*
1002       this is needed to make valgrind/purify happier.  the other
1003       solution is throw an exception, but since this code should work
1004       with plain C ....
1005      */
1006     memset((void*)&v, 0, sizeof(int));
1007   }
1008   return v;
1009 }
1010
1011 extern int ic7_memory;
1012 extern BOOL rfe_enabled;
1013 extern BOOL xvtr_enabled;
1014 extern BOOL pa_enabled;
1015 extern BandSetting band_relay;
1016 extern int external_output;
1017 extern int mute_relay;
1018 extern int transmit_relay;
1019 extern int gain_relay;
1020 extern int latch_delay;
1021 extern double dds_clock;
1022 extern int pll_mult;
1023 extern double dds_clock_correction;
1024 extern double sysClock;
1025 extern int ioud_clock;
1026 extern ushort dac_mult;
1027 extern double dds_freq;
1028 extern double if_freq;
1029 extern BOOL if_shift;
1030 extern BOOL spur_reduction;
1031 extern double dds_step_size;
1032 extern int sample_rate;
1033 extern int fft_length;
1034 extern double FFT_Bin_Size;
1035 extern int tune_fft;
1036 extern double tune_frac_rel;
1037 extern double vfo_offset;
1038 extern double min_freq;
1039 extern double max_freq;
1040 extern u_short baseAdr;
1041 extern BandPlan curBandPlan;
1042 extern double TWO_TO_THE_48_DIVIDED_BY_200;
1043 extern long last_tuning_word;
1044
1045 SWIGSTATICINLINE(long)
1046 SWIG_As_long(PyObject* obj)
1047 {
1048   long v;
1049   if (!SWIG_AsVal_long(obj, &v)) {
1050     /*
1051       this is needed to make valgrind/purify happier.  the other
1052       solution is throw an exception, but since this code should work
1053       with plain C ....
1054      */
1055     memset((void*)&v, 0, sizeof(long));
1056   }
1057   return v;
1058 }
1059
1060 extern BOOL usb_enabled;
1061 extern BOOL openPort(char *);
1062
1063 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1064 SWIGSTATIC(int)
1065 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1066 {
1067   static swig_type_info* pchar_info = 0;
1068   char* vptr = 0;
1069   if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1070   if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1071     if (cptr) *cptr = vptr;
1072     if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1073     return SWIG_OLDOBJ;
1074   } else {
1075     if (PyString_Check(obj)) {
1076       if (cptr) {
1077         *cptr = PyString_AS_STRING(obj);
1078         if (psize) {
1079           *psize = PyString_GET_SIZE(obj) + 1;
1080         }
1081       }
1082       return SWIG_PYSTR;
1083     }
1084   }
1085   if (cptr) {
1086     PyErr_SetString(PyExc_TypeError, "a string is expected");
1087   }
1088   return 0;
1089 }
1090
1091
1092 SWIGSTATICINLINE(int)
1093 SWIG_AsCharPtr(PyObject *obj, char **val)
1094 {
1095   char* cptr = 0;
1096   if (SWIG_AsCharPtrAndSize(obj, &cptr, (size_t*)(0))) {
1097     if (val) *val = cptr;
1098     return 1;
1099   }
1100   if (val) {
1101     PyErr_SetString(PyExc_TypeError, "a char* is expected");
1102   }
1103   return 0;
1104 }
1105
1106 extern void closePort(void);
1107 extern void USB_Sdr1kLatch(int,BYTE);
1108
1109 SWIGSTATICINLINE(int)
1110   SWIG_AsVal_unsigned_SS_long(PyObject * obj, unsigned long *val) 
1111 {
1112   if (PyInt_Check(obj)) {
1113     long v = PyInt_AS_LONG(obj);
1114     if (v >= 0) {
1115       if (val) *val = v;
1116       return 1;
1117     }   
1118   }
1119   if (PyLong_Check(obj)) {
1120     unsigned long v = PyLong_AsUnsignedLong(obj);
1121     if (!PyErr_Occurred()) {
1122       if (val) *val = v;
1123       return 1;
1124     } else {
1125       if (!val) PyErr_Clear();
1126       return 0;
1127     }
1128   } 
1129   if (val) {
1130     PyErr_SetString(PyExc_TypeError, "an unsigned long is expected");
1131   }
1132   return 0;
1133 }
1134
1135
1136 SWIGSTATICINLINE(int)
1137   SWIG_CheckUnsignedLongInRange(unsigned long value,
1138                                 unsigned long max_value,
1139                                 const char *errmsg) 
1140 {
1141   if (value > max_value) {
1142     if (errmsg) {
1143       PyErr_Format(PyExc_OverflowError,
1144                    "value %ld is greater than '%s' minimum %ld",
1145                    value, errmsg, max_value);
1146     }
1147     return 0;
1148   }
1149   return 1;
1150  }
1151
1152
1153 SWIGSTATICINLINE(int)
1154   SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
1155
1156   const char* errmsg = val ? "unsigned char" : 0;
1157   unsigned long v;
1158   if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
1159     if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
1160       if (val) *val = swig_numeric_cast(v, unsigned char);
1161       return 1;
1162     } else {
1163       return 0;
1164     }
1165   } else {
1166     PyErr_Clear();
1167   }
1168   if (val) {
1169     PyErr_SetString(PyExc_TypeError, "an unsigned char is expected");
1170   }
1171   return 0;
1172 }
1173
1174
1175 SWIGSTATICINLINE(unsigned char)
1176 SWIG_As_unsigned_SS_char(PyObject* obj)
1177 {
1178   unsigned char v;
1179   if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
1180     /*
1181       this is needed to make valgrind/purify happier.  the other
1182       solution is throw an exception, but since this code should work
1183       with plain C ....
1184      */
1185     memset((void*)&v, 0, sizeof(unsigned char));
1186   }
1187   return v;
1188 }
1189
1190   
1191 SWIGSTATICINLINE(int)
1192 SWIG_Check_int(PyObject* obj)
1193 {
1194   return SWIG_AsVal_int(obj, (int*)0);
1195 }
1196
1197   
1198 SWIGSTATICINLINE(int)
1199 SWIG_Check_unsigned_SS_char(PyObject* obj)
1200 {
1201   return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
1202 }
1203
1204 extern BYTE USB_Sdr1kGetStatusPort(void);
1205 extern int USB_Sdr1kGetADC(void);
1206 extern void USB_Sdr1kDDSReset(void);
1207 extern void USB_Sdr1kDDSWrite(BYTE,BYTE);
1208 extern void USB_Sdr1kSRLoad(BYTE,BYTE);
1209 extern void DttSP_ChangeOsc(double);
1210   
1211 SWIGSTATICINLINE(int)
1212 SWIG_Check_double(PyObject* obj)
1213 {
1214   return SWIG_AsVal_double(obj, (double*)0);
1215 }
1216
1217 extern void Init(void);
1218 extern void PowerOn(void);
1219 extern void StandBy(void);
1220 extern void Impulse(void);
1221 extern BYTE StatusPort(void);
1222 extern void SetExt(ExtPin);
1223 extern void ResExt(ExtPin);
1224 extern BOOL PinValue(ExtPin);
1225 extern void SetBPF(double);
1226 extern void TestPort(void);
1227 extern void RCKStrobe(BOOL,RFE_RCK);
1228 extern void SRLoad(RFE_RCK,int);
1229 extern void ResetRFE(void);
1230 extern void PA_SetLPF(int);
1231 extern BYTE PA_GetADC(int);
1232 extern BOOL PA_ATUTune(ATUTuneMode);
1233 extern BOOL getEnableLPF0(void);
1234 extern void setEnableLPF0(BOOL);
1235 extern BOOL getExtended(void);
1236 extern void setExtended(BOOL);
1237 extern BOOL getX2Enabled(void);
1238 extern void setX2Enabled(BOOL);
1239 extern int getX2Delay(void);
1240 extern void setX2Delay(int);
1241 extern BOOL getRFE_Enabled(void);
1242 extern void setRFE_Enabled(BOOL);
1243 extern BOOL getPA_Enabled(void);
1244 extern void setPA_Enabled(BOOL);
1245 extern BOOL getXVTR_Enabled(void);
1246 extern BOOL setXVTR_Enabled(BOOL);
1247 extern BOOL getUSB_Enabled(void);
1248 extern void setUSB_Enabled(BOOL);
1249 extern XVTRTRMode getCurrentXVTRTRMode(void);
1250 extern void setCurrentXVTRTRMode(XVTRTRMode);
1251 extern int getLatchDelay(void);
1252 extern void setLatchDelay(int);
1253 extern double getMinFreq(void);
1254 extern double getMaxFreq(void);
1255 extern u_short getBaseAddr(void);
1256 extern u_short setBaseAddr(u_short);
1257 extern BandSetting getBandRelay(void);
1258 extern void setBandRelay(BandSetting);
1259 extern BOOL getTransmitRelay(void);
1260 extern void setTransmitRelay(BOOL);
1261 extern BOOL getMuteRelay(void);
1262 extern void setMuteRelay(BOOL);
1263 extern BOOL getGainRelay(void);
1264 extern void setGainRelay(BOOL);
1265 extern int getExternalOutput(void);
1266 extern void setExternalOutput(int);
1267 extern double getDDSClockCorrection(void);
1268 extern void setDDSClockCorrection(double);
1269 extern int getPLLMult(void);
1270 extern void setPLLMult(int);
1271 extern double getDDSClock(void);
1272 extern void setDDSClock(double);
1273 extern BOOL getIFShift(void);
1274 extern void setIFShift(BOOL);
1275 extern BOOL getSpurReduction(void);
1276 extern BOOL setSpurReduction(BOOL);
1277 extern double getIFFreq(void);
1278 extern void setIFFreq(double);
1279 extern double getDDSFreq(void);
1280 extern void setDDSFreq(double);
1281 extern int getSampleRate(void);
1282 extern void setSampleRate(int);
1283 extern int getFFTLength(void);
1284 extern void setFFTLength(int);
1285 extern int getTuneFFT(void);
1286 extern double getTuneFracRel(void);
1287 extern double getVFOOffset(void);
1288 extern void setVFOOffset(double);
1289 extern int getIOUDClock(void);
1290 extern void setIOUDClock(int);
1291 extern u_short getDACMult(void);
1292 extern void setDACMult(u_short);
1293 extern BOOL getAMP_Relay(void);
1294 extern BOOL setAMP_Relay(BOOL);
1295 extern BOOL getATTN_Relay(void);
1296 extern void setATTN_Relay(BOOL);
1297 extern BOOL getXVTR_TR_Relay(void);
1298 extern BOOL setXVTR_TR_Relay(BOOL);
1299 extern BOOL getXVTR_Relay(void);
1300 extern BOOL setXVTR_Relay(BOOL);
1301 extern BOOL getIMPULSE_Relay(void);
1302 extern BOOL setIMPULSE_Relay(BOOL);
1303 extern BOOL getPA_TransmitRelay(void);
1304 extern BOOL setPA_TransmitRelay(BOOL);
1305 extern BOOL getPA_BiasOn(void);
1306 extern BOOL setPA_BiasOn(BOOL);
1307 #ifdef __cplusplus
1308 extern "C" {
1309 #endif
1310 static int _wrap_DttSP_SampleRate_set(PyObject *_val) {
1311     {
1312         double temp = (double) SWIG_As_double(_val);  
1313         if (PyErr_Occurred()) {
1314             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'DttSP_SampleRate (double)'");
1315             return 1;
1316         }
1317         DttSP_SampleRate = temp;
1318     }
1319     return 0;
1320 }
1321
1322
1323 static PyObject *_wrap_DttSP_SampleRate_get() {
1324     PyObject *pyobj;
1325     
1326     pyobj = SWIG_From_double((double)DttSP_SampleRate);
1327     return pyobj;
1328 }
1329
1330
1331 static int _wrap_ic11_memory_set(PyObject *_val) {
1332     {
1333         int temp = (int) SWIG_As_int(_val);  
1334         if (PyErr_Occurred()) {
1335             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ic11_memory (int)'");
1336             return 1;
1337         }
1338         ic11_memory = temp;
1339     }
1340     return 0;
1341 }
1342
1343
1344 static PyObject *_wrap_ic11_memory_get() {
1345     PyObject *pyobj;
1346     
1347     pyobj = SWIG_From_int((int)ic11_memory);
1348     return pyobj;
1349 }
1350
1351
1352 static int _wrap_ic7_memory_set(PyObject *_val) {
1353     {
1354         int temp = (int) SWIG_As_int(_val);  
1355         if (PyErr_Occurred()) {
1356             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ic7_memory (int)'");
1357             return 1;
1358         }
1359         ic7_memory = temp;
1360     }
1361     return 0;
1362 }
1363
1364
1365 static PyObject *_wrap_ic7_memory_get() {
1366     PyObject *pyobj;
1367     
1368     pyobj = SWIG_From_int((int)ic7_memory);
1369     return pyobj;
1370 }
1371
1372
1373 static int _wrap_rfe_enabled_set(PyObject *_val) {
1374     {
1375         BOOL temp = (BOOL) SWIG_As_int(_val);  
1376         if (PyErr_Occurred()) {
1377             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'rfe_enabled (BOOL)'");
1378             return 1;
1379         }
1380         rfe_enabled = temp;
1381     }
1382     return 0;
1383 }
1384
1385
1386 static PyObject *_wrap_rfe_enabled_get() {
1387     PyObject *pyobj;
1388     
1389     pyobj = SWIG_From_int((int)rfe_enabled);
1390     return pyobj;
1391 }
1392
1393
1394 static int _wrap_xvtr_enabled_set(PyObject *_val) {
1395     {
1396         BOOL temp = (BOOL) SWIG_As_int(_val);  
1397         if (PyErr_Occurred()) {
1398             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'xvtr_enabled (BOOL)'");
1399             return 1;
1400         }
1401         xvtr_enabled = temp;
1402     }
1403     return 0;
1404 }
1405
1406
1407 static PyObject *_wrap_xvtr_enabled_get() {
1408     PyObject *pyobj;
1409     
1410     pyobj = SWIG_From_int((int)xvtr_enabled);
1411     return pyobj;
1412 }
1413
1414
1415 static int _wrap_pa_enabled_set(PyObject *_val) {
1416     {
1417         BOOL temp = (BOOL) SWIG_As_int(_val);  
1418         if (PyErr_Occurred()) {
1419             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pa_enabled (BOOL)'");
1420             return 1;
1421         }
1422         pa_enabled = temp;
1423     }
1424     return 0;
1425 }
1426
1427
1428 static PyObject *_wrap_pa_enabled_get() {
1429     PyObject *pyobj;
1430     
1431     pyobj = SWIG_From_int((int)pa_enabled);
1432     return pyobj;
1433 }
1434
1435
1436 static int _wrap_band_relay_set(PyObject *_val) {
1437     {
1438         if (sizeof(int) != sizeof(band_relay)) {
1439             PyErr_SetString(PyExc_TypeError, "enum variable 'band_relay' can not be set");
1440             return 1;
1441         }  
1442         if (!SWIG_AsVal_int(_val, (int*)(void*)&(band_relay))) {
1443             return 1;
1444         }
1445     }
1446     return 0;
1447 }
1448
1449
1450 static PyObject *_wrap_band_relay_get() {
1451     PyObject *pyobj;
1452     
1453     pyobj = SWIG_From_int((int)band_relay);
1454     return pyobj;
1455 }
1456
1457
1458 static int _wrap_external_output_set(PyObject *_val) {
1459     {
1460         int temp = (int) SWIG_As_int(_val);  
1461         if (PyErr_Occurred()) {
1462             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'external_output (int)'");
1463             return 1;
1464         }
1465         external_output = temp;
1466     }
1467     return 0;
1468 }
1469
1470
1471 static PyObject *_wrap_external_output_get() {
1472     PyObject *pyobj;
1473     
1474     pyobj = SWIG_From_int((int)external_output);
1475     return pyobj;
1476 }
1477
1478
1479 static int _wrap_mute_relay_set(PyObject *_val) {
1480     {
1481         int temp = (int) SWIG_As_int(_val);  
1482         if (PyErr_Occurred()) {
1483             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'mute_relay (int)'");
1484             return 1;
1485         }
1486         mute_relay = temp;
1487     }
1488     return 0;
1489 }
1490
1491
1492 static PyObject *_wrap_mute_relay_get() {
1493     PyObject *pyobj;
1494     
1495     pyobj = SWIG_From_int((int)mute_relay);
1496     return pyobj;
1497 }
1498
1499
1500 static int _wrap_transmit_relay_set(PyObject *_val) {
1501     {
1502         int temp = (int) SWIG_As_int(_val);  
1503         if (PyErr_Occurred()) {
1504             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'transmit_relay (int)'");
1505             return 1;
1506         }
1507         transmit_relay = temp;
1508     }
1509     return 0;
1510 }
1511
1512
1513 static PyObject *_wrap_transmit_relay_get() {
1514     PyObject *pyobj;
1515     
1516     pyobj = SWIG_From_int((int)transmit_relay);
1517     return pyobj;
1518 }
1519
1520
1521 static int _wrap_gain_relay_set(PyObject *_val) {
1522     {
1523         int temp = (int) SWIG_As_int(_val);  
1524         if (PyErr_Occurred()) {
1525             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'gain_relay (int)'");
1526             return 1;
1527         }
1528         gain_relay = temp;
1529     }
1530     return 0;
1531 }
1532
1533
1534 static PyObject *_wrap_gain_relay_get() {
1535     PyObject *pyobj;
1536     
1537     pyobj = SWIG_From_int((int)gain_relay);
1538     return pyobj;
1539 }
1540
1541
1542 static int _wrap_latch_delay_set(PyObject *_val) {
1543     {
1544         int temp = (int) SWIG_As_int(_val);  
1545         if (PyErr_Occurred()) {
1546             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'latch_delay (int)'");
1547             return 1;
1548         }
1549         latch_delay = temp;
1550     }
1551     return 0;
1552 }
1553
1554
1555 static PyObject *_wrap_latch_delay_get() {
1556     PyObject *pyobj;
1557     
1558     pyobj = SWIG_From_int((int)latch_delay);
1559     return pyobj;
1560 }
1561
1562
1563 static int _wrap_dds_clock_set(PyObject *_val) {
1564     {
1565         double temp = (double) SWIG_As_double(_val);  
1566         if (PyErr_Occurred()) {
1567             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_clock (double)'");
1568             return 1;
1569         }
1570         dds_clock = temp;
1571     }
1572     return 0;
1573 }
1574
1575
1576 static PyObject *_wrap_dds_clock_get() {
1577     PyObject *pyobj;
1578     
1579     pyobj = SWIG_From_double((double)dds_clock);
1580     return pyobj;
1581 }
1582
1583
1584 static int _wrap_pll_mult_set(PyObject *_val) {
1585     {
1586         int temp = (int) SWIG_As_int(_val);  
1587         if (PyErr_Occurred()) {
1588             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'pll_mult (int)'");
1589             return 1;
1590         }
1591         pll_mult = temp;
1592     }
1593     return 0;
1594 }
1595
1596
1597 static PyObject *_wrap_pll_mult_get() {
1598     PyObject *pyobj;
1599     
1600     pyobj = SWIG_From_int((int)pll_mult);
1601     return pyobj;
1602 }
1603
1604
1605 static int _wrap_dds_clock_correction_set(PyObject *_val) {
1606     {
1607         double temp = (double) SWIG_As_double(_val);  
1608         if (PyErr_Occurred()) {
1609             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_clock_correction (double)'");
1610             return 1;
1611         }
1612         dds_clock_correction = temp;
1613     }
1614     return 0;
1615 }
1616
1617
1618 static PyObject *_wrap_dds_clock_correction_get() {
1619     PyObject *pyobj;
1620     
1621     pyobj = SWIG_From_double((double)dds_clock_correction);
1622     return pyobj;
1623 }
1624
1625
1626 static int _wrap_sysClock_set(PyObject *_val) {
1627     {
1628         double temp = (double) SWIG_As_double(_val);  
1629         if (PyErr_Occurred()) {
1630             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'sysClock (double)'");
1631             return 1;
1632         }
1633         sysClock = temp;
1634     }
1635     return 0;
1636 }
1637
1638
1639 static PyObject *_wrap_sysClock_get() {
1640     PyObject *pyobj;
1641     
1642     pyobj = SWIG_From_double((double)sysClock);
1643     return pyobj;
1644 }
1645
1646
1647 static int _wrap_ioud_clock_set(PyObject *_val) {
1648     {
1649         int temp = (int) SWIG_As_int(_val);  
1650         if (PyErr_Occurred()) {
1651             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'ioud_clock (int)'");
1652             return 1;
1653         }
1654         ioud_clock = temp;
1655     }
1656     return 0;
1657 }
1658
1659
1660 static PyObject *_wrap_ioud_clock_get() {
1661     PyObject *pyobj;
1662     
1663     pyobj = SWIG_From_int((int)ioud_clock);
1664     return pyobj;
1665 }
1666
1667
1668 static int _wrap_dac_mult_set(PyObject *_val) {
1669     {
1670         ushort * temp;
1671         if ((SWIG_ConvertPtr(_val, (void **)(&temp), SWIGTYPE_p_ushort, SWIG_POINTER_EXCEPTION)) == -1) {
1672             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dac_mult (ushort)'");
1673             return 1;
1674         }
1675         dac_mult = *((ushort *) temp);
1676     }
1677     return 0;
1678 }
1679
1680
1681 static PyObject *_wrap_dac_mult_get() {
1682     PyObject *pyobj;
1683     
1684     pyobj = SWIG_NewPointerObj((void *)(&dac_mult), SWIGTYPE_p_ushort, 0);
1685     return pyobj;
1686 }
1687
1688
1689 static int _wrap_dds_freq_set(PyObject *_val) {
1690     {
1691         double temp = (double) SWIG_As_double(_val);  
1692         if (PyErr_Occurred()) {
1693             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_freq (double)'");
1694             return 1;
1695         }
1696         dds_freq = temp;
1697     }
1698     return 0;
1699 }
1700
1701
1702 static PyObject *_wrap_dds_freq_get() {
1703     PyObject *pyobj;
1704     
1705     pyobj = SWIG_From_double((double)dds_freq);
1706     return pyobj;
1707 }
1708
1709
1710 static int _wrap_if_freq_set(PyObject *_val) {
1711     {
1712         double temp = (double) SWIG_As_double(_val);  
1713         if (PyErr_Occurred()) {
1714             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'if_freq (double)'");
1715             return 1;
1716         }
1717         if_freq = temp;
1718     }
1719     return 0;
1720 }
1721
1722
1723 static PyObject *_wrap_if_freq_get() {
1724     PyObject *pyobj;
1725     
1726     pyobj = SWIG_From_double((double)if_freq);
1727     return pyobj;
1728 }
1729
1730
1731 static int _wrap_if_shift_set(PyObject *_val) {
1732     {
1733         BOOL temp = (BOOL) SWIG_As_int(_val);  
1734         if (PyErr_Occurred()) {
1735             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'if_shift (BOOL)'");
1736             return 1;
1737         }
1738         if_shift = temp;
1739     }
1740     return 0;
1741 }
1742
1743
1744 static PyObject *_wrap_if_shift_get() {
1745     PyObject *pyobj;
1746     
1747     pyobj = SWIG_From_int((int)if_shift);
1748     return pyobj;
1749 }
1750
1751
1752 static int _wrap_spur_reduction_set(PyObject *_val) {
1753     {
1754         BOOL temp = (BOOL) SWIG_As_int(_val);  
1755         if (PyErr_Occurred()) {
1756             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'spur_reduction (BOOL)'");
1757             return 1;
1758         }
1759         spur_reduction = temp;
1760     }
1761     return 0;
1762 }
1763
1764
1765 static PyObject *_wrap_spur_reduction_get() {
1766     PyObject *pyobj;
1767     
1768     pyobj = SWIG_From_int((int)spur_reduction);
1769     return pyobj;
1770 }
1771
1772
1773 static int _wrap_dds_step_size_set(PyObject *_val) {
1774     {
1775         double temp = (double) SWIG_As_double(_val);  
1776         if (PyErr_Occurred()) {
1777             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'dds_step_size (double)'");
1778             return 1;
1779         }
1780         dds_step_size = temp;
1781     }
1782     return 0;
1783 }
1784
1785
1786 static PyObject *_wrap_dds_step_size_get() {
1787     PyObject *pyobj;
1788     
1789     pyobj = SWIG_From_double((double)dds_step_size);
1790     return pyobj;
1791 }
1792
1793
1794 static int _wrap_sample_rate_set(PyObject *_val) {
1795     {
1796         int temp = (int) SWIG_As_int(_val);  
1797         if (PyErr_Occurred()) {
1798             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'sample_rate (int)'");
1799             return 1;
1800         }
1801         sample_rate = temp;
1802     }
1803     return 0;
1804 }
1805
1806
1807 static PyObject *_wrap_sample_rate_get() {
1808     PyObject *pyobj;
1809     
1810     pyobj = SWIG_From_int((int)sample_rate);
1811     return pyobj;
1812 }
1813
1814
1815 static int _wrap_fft_length_set(PyObject *_val) {
1816     {
1817         int temp = (int) SWIG_As_int(_val);  
1818         if (PyErr_Occurred()) {
1819             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'fft_length (int)'");
1820             return 1;
1821         }
1822         fft_length = temp;
1823     }
1824     return 0;
1825 }
1826
1827
1828 static PyObject *_wrap_fft_length_get() {
1829     PyObject *pyobj;
1830     
1831     pyobj = SWIG_From_int((int)fft_length);
1832     return pyobj;
1833 }
1834
1835
1836 static int _wrap_FFT_Bin_Size_set(PyObject *_val) {
1837     {
1838         double temp = (double) SWIG_As_double(_val);  
1839         if (PyErr_Occurred()) {
1840             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'FFT_Bin_Size (double)'");
1841             return 1;
1842         }
1843         FFT_Bin_Size = temp;
1844     }
1845     return 0;
1846 }
1847
1848
1849 static PyObject *_wrap_FFT_Bin_Size_get() {
1850     PyObject *pyobj;
1851     
1852     pyobj = SWIG_From_double((double)FFT_Bin_Size);
1853     return pyobj;
1854 }
1855
1856
1857 static int _wrap_tune_fft_set(PyObject *_val) {
1858     {
1859         int temp = (int) SWIG_As_int(_val);  
1860         if (PyErr_Occurred()) {
1861             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'tune_fft (int)'");
1862             return 1;
1863         }
1864         tune_fft = temp;
1865     }
1866     return 0;
1867 }
1868
1869
1870 static PyObject *_wrap_tune_fft_get() {
1871     PyObject *pyobj;
1872     
1873     pyobj = SWIG_From_int((int)tune_fft);
1874     return pyobj;
1875 }
1876
1877
1878 static int _wrap_tune_frac_rel_set(PyObject *_val) {
1879     {
1880         double temp = (double) SWIG_As_double(_val);  
1881         if (PyErr_Occurred()) {
1882             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'tune_frac_rel (double)'");
1883             return 1;
1884         }
1885         tune_frac_rel = temp;
1886     }
1887     return 0;
1888 }
1889
1890
1891 static PyObject *_wrap_tune_frac_rel_get() {
1892     PyObject *pyobj;
1893     
1894     pyobj = SWIG_From_double((double)tune_frac_rel);
1895     return pyobj;
1896 }
1897
1898
1899 static int _wrap_vfo_offset_set(PyObject *_val) {
1900     {
1901         double temp = (double) SWIG_As_double(_val);  
1902         if (PyErr_Occurred()) {
1903             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'vfo_offset (double)'");
1904             return 1;
1905         }
1906         vfo_offset = temp;
1907     }
1908     return 0;
1909 }
1910
1911
1912 static PyObject *_wrap_vfo_offset_get() {
1913     PyObject *pyobj;
1914     
1915     pyobj = SWIG_From_double((double)vfo_offset);
1916     return pyobj;
1917 }
1918
1919
1920 static int _wrap_min_freq_set(PyObject *_val) {
1921     {
1922         double temp = (double) SWIG_As_double(_val);  
1923         if (PyErr_Occurred()) {
1924             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'min_freq (double)'");
1925             return 1;
1926         }
1927         min_freq = temp;
1928     }
1929     return 0;
1930 }
1931
1932
1933 static PyObject *_wrap_min_freq_get() {
1934     PyObject *pyobj;
1935     
1936     pyobj = SWIG_From_double((double)min_freq);
1937     return pyobj;
1938 }
1939
1940
1941 static int _wrap_max_freq_set(PyObject *_val) {
1942     {
1943         double temp = (double) SWIG_As_double(_val);  
1944         if (PyErr_Occurred()) {
1945             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'max_freq (double)'");
1946             return 1;
1947         }
1948         max_freq = temp;
1949     }
1950     return 0;
1951 }
1952
1953
1954 static PyObject *_wrap_max_freq_get() {
1955     PyObject *pyobj;
1956     
1957     pyobj = SWIG_From_double((double)max_freq);
1958     return pyobj;
1959 }
1960
1961
1962 static int _wrap_baseAdr_set(PyObject *_val) {
1963     {
1964         u_short * temp;
1965         if ((SWIG_ConvertPtr(_val, (void **)(&temp), SWIGTYPE_p_u_short, SWIG_POINTER_EXCEPTION)) == -1) {
1966             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'baseAdr (u_short)'");
1967             return 1;
1968         }
1969         baseAdr = *((u_short *) temp);
1970     }
1971     return 0;
1972 }
1973
1974
1975 static PyObject *_wrap_baseAdr_get() {
1976     PyObject *pyobj;
1977     
1978     pyobj = SWIG_NewPointerObj((void *)(&baseAdr), SWIGTYPE_p_u_short, 0);
1979     return pyobj;
1980 }
1981
1982
1983 static int _wrap_curBandPlan_set(PyObject *_val) {
1984     {
1985         if (sizeof(int) != sizeof(curBandPlan)) {
1986             PyErr_SetString(PyExc_TypeError, "enum variable 'curBandPlan' can not be set");
1987             return 1;
1988         }  
1989         if (!SWIG_AsVal_int(_val, (int*)(void*)&(curBandPlan))) {
1990             return 1;
1991         }
1992     }
1993     return 0;
1994 }
1995
1996
1997 static PyObject *_wrap_curBandPlan_get() {
1998     PyObject *pyobj;
1999     
2000     pyobj = SWIG_From_int((int)curBandPlan);
2001     return pyobj;
2002 }
2003
2004
2005 static int _wrap_TWO_TO_THE_48_DIVIDED_BY_200_set(PyObject *_val) {
2006     {
2007         double temp = (double) SWIG_As_double(_val);  
2008         if (PyErr_Occurred()) {
2009             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'TWO_TO_THE_48_DIVIDED_BY_200 (double)'");
2010             return 1;
2011         }
2012         TWO_TO_THE_48_DIVIDED_BY_200 = temp;
2013     }
2014     return 0;
2015 }
2016
2017
2018 static PyObject *_wrap_TWO_TO_THE_48_DIVIDED_BY_200_get() {
2019     PyObject *pyobj;
2020     
2021     pyobj = SWIG_From_double((double)TWO_TO_THE_48_DIVIDED_BY_200);
2022     return pyobj;
2023 }
2024
2025
2026 static int _wrap_last_tuning_word_set(PyObject *_val) {
2027     {
2028         long temp = (long) SWIG_As_long(_val);  
2029         if (PyErr_Occurred()) {
2030             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'last_tuning_word (long)'");
2031             return 1;
2032         }
2033         last_tuning_word = temp;
2034     }
2035     return 0;
2036 }
2037
2038
2039 static PyObject *_wrap_last_tuning_word_get() {
2040     PyObject *pyobj;
2041     
2042     pyobj = SWIG_From_long((long)last_tuning_word);
2043     return pyobj;
2044 }
2045
2046
2047 static int _wrap_usb_enabled_set(PyObject *_val) {
2048     {
2049         BOOL temp = (BOOL) SWIG_As_int(_val);  
2050         if (PyErr_Occurred()) {
2051             PyErr_SetString(PyExc_TypeError, "C/C++ variable 'usb_enabled (BOOL)'");
2052             return 1;
2053         }
2054         usb_enabled = temp;
2055     }
2056     return 0;
2057 }
2058
2059
2060 static PyObject *_wrap_usb_enabled_get() {
2061     PyObject *pyobj;
2062     
2063     pyobj = SWIG_From_int((int)usb_enabled);
2064     return pyobj;
2065 }
2066
2067
2068 static PyObject *_wrap_openPort(PyObject *self, PyObject *args) {
2069     PyObject *resultobj;
2070     char *arg1 ;
2071     BOOL result;
2072     PyObject * obj0 = 0 ;
2073     
2074     if(!PyArg_ParseTuple(args,(char *)"O:openPort",&obj0)) goto fail;
2075     if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) SWIG_fail;
2076     result = (BOOL)openPort(arg1);
2077     
2078     resultobj = SWIG_From_int((int)result);
2079     return resultobj;
2080     fail:
2081     return NULL;
2082 }
2083
2084
2085 static PyObject *_wrap_closePort(PyObject *self, PyObject *args) {
2086     PyObject *resultobj;
2087     
2088     if(!PyArg_ParseTuple(args,(char *)":closePort")) goto fail;
2089     closePort();
2090     
2091     Py_INCREF(Py_None); resultobj = Py_None;
2092     return resultobj;
2093     fail:
2094     return NULL;
2095 }
2096
2097
2098 static PyObject *_wrap_USB_Sdr1kLatch(PyObject *self, PyObject *args) {
2099     PyObject *resultobj;
2100     int arg1 ;
2101     BYTE arg2 ;
2102     PyObject * obj0 = 0 ;
2103     PyObject * obj1 = 0 ;
2104     
2105     if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kLatch",&obj0,&obj1)) goto fail;
2106     arg1 = (int)SWIG_As_int(obj0); 
2107     if (PyErr_Occurred()) SWIG_fail;
2108     arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); 
2109     if (PyErr_Occurred()) SWIG_fail;
2110     USB_Sdr1kLatch(arg1,arg2);
2111     
2112     Py_INCREF(Py_None); resultobj = Py_None;
2113     return resultobj;
2114     fail:
2115     return NULL;
2116 }
2117
2118
2119 static PyObject *_wrap_USB_Sdr1kGetStatusPort(PyObject *self, PyObject *args) {
2120     PyObject *resultobj;
2121     BYTE result;
2122     
2123     if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kGetStatusPort")) goto fail;
2124     result = (BYTE)USB_Sdr1kGetStatusPort();
2125     
2126     resultobj = SWIG_From_unsigned_SS_char((unsigned char)result);
2127     return resultobj;
2128     fail:
2129     return NULL;
2130 }
2131
2132
2133 static PyObject *_wrap_USB_Sdr1kGetADC(PyObject *self, PyObject *args) {
2134     PyObject *resultobj;
2135     int result;
2136     
2137     if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kGetADC")) goto fail;
2138     result = (int)USB_Sdr1kGetADC();
2139     
2140     resultobj = SWIG_From_int((int)result);
2141     return resultobj;
2142     fail:
2143     return NULL;
2144 }
2145
2146
2147 static PyObject *_wrap_USB_Sdr1kDDSReset(PyObject *self, PyObject *args) {
2148     PyObject *resultobj;
2149     
2150     if(!PyArg_ParseTuple(args,(char *)":USB_Sdr1kDDSReset")) goto fail;
2151     USB_Sdr1kDDSReset();
2152     
2153     Py_INCREF(Py_None); resultobj = Py_None;
2154     return resultobj;
2155     fail:
2156     return NULL;
2157 }
2158
2159
2160 static PyObject *_wrap_USB_Sdr1kDDSWrite(PyObject *self, PyObject *args) {
2161     PyObject *resultobj;
2162     BYTE arg1 ;
2163     BYTE arg2 ;
2164     PyObject * obj0 = 0 ;
2165     PyObject * obj1 = 0 ;
2166     
2167     if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kDDSWrite",&obj0,&obj1)) goto fail;
2168     arg1 = (BYTE)SWIG_As_unsigned_SS_char(obj0); 
2169     if (PyErr_Occurred()) SWIG_fail;
2170     arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); 
2171     if (PyErr_Occurred()) SWIG_fail;
2172     USB_Sdr1kDDSWrite(arg1,arg2);
2173     
2174     Py_INCREF(Py_None); resultobj = Py_None;
2175     return resultobj;
2176     fail:
2177     return NULL;
2178 }
2179
2180
2181 static PyObject *_wrap_USB_Sdr1kSRLoad(PyObject *self, PyObject *args) {
2182     PyObject *resultobj;
2183     BYTE arg1 ;
2184     BYTE arg2 ;
2185     PyObject * obj0 = 0 ;
2186     PyObject * obj1 = 0 ;
2187     
2188     if(!PyArg_ParseTuple(args,(char *)"OO:USB_Sdr1kSRLoad",&obj0,&obj1)) goto fail;
2189     arg1 = (BYTE)SWIG_As_unsigned_SS_char(obj0); 
2190     if (PyErr_Occurred()) SWIG_fail;
2191     arg2 = (BYTE)SWIG_As_unsigned_SS_char(obj1); 
2192     if (PyErr_Occurred()) SWIG_fail;
2193     USB_Sdr1kSRLoad(arg1,arg2);
2194     
2195     Py_INCREF(Py_None); resultobj = Py_None;
2196     return resultobj;
2197     fail:
2198     return NULL;
2199 }
2200
2201
2202 static PyObject *_wrap_DttSP_ChangeOsc(PyObject *self, PyObject *args) {
2203     PyObject *resultobj;
2204     double arg1 ;
2205     PyObject * obj0 = 0 ;
2206     
2207     if(!PyArg_ParseTuple(args,(char *)"O:DttSP_ChangeOsc",&obj0)) goto fail;
2208     arg1 = (double)SWIG_As_double(obj0); 
2209     if (PyErr_Occurred()) SWIG_fail;
2210     DttSP_ChangeOsc(arg1);
2211     
2212     Py_INCREF(Py_None); resultobj = Py_None;
2213     return resultobj;
2214     fail:
2215     return NULL;
2216 }
2217
2218
2219 static PyObject *_wrap_Init(PyObject *self, PyObject *args) {
2220     PyObject *resultobj;
2221     
2222     if(!PyArg_ParseTuple(args,(char *)":Init")) goto fail;
2223     Init();
2224     
2225     Py_INCREF(Py_None); resultobj = Py_None;
2226     return resultobj;
2227     fail:
2228     return NULL;
2229 }
2230
2231
2232 static PyObject *_wrap_PowerOn(PyObject *self, PyObject *args) {
2233     PyObject *resultobj;
2234     
2235     if(!PyArg_ParseTuple(args,(char *)":PowerOn")) goto fail;
2236     PowerOn();
2237     
2238     Py_INCREF(Py_None); resultobj = Py_None;
2239     return resultobj;
2240     fail:
2241     return NULL;
2242 }
2243
2244
2245 static PyObject *_wrap_StandBy(PyObject *self, PyObject *args) {
2246     PyObject *resultobj;
2247     
2248     if(!PyArg_ParseTuple(args,(char *)":StandBy")) goto fail;
2249     StandBy();
2250     
2251     Py_INCREF(Py_None); resultobj = Py_None;
2252     return resultobj;
2253     fail:
2254     return NULL;
2255 }
2256
2257
2258 static PyObject *_wrap_Impulse(PyObject *self, PyObject *args) {
2259     PyObject *resultobj;
2260     
2261     if(!PyArg_ParseTuple(args,(char *)":Impulse")) goto fail;
2262     Impulse();
2263     
2264     Py_INCREF(Py_None); resultobj = Py_None;
2265     return resultobj;
2266     fail:
2267     return NULL;
2268 }
2269
2270
2271 static PyObject *_wrap_StatusPort(PyObject *self, PyObject *args) {
2272     PyObject *resultobj;
2273     BYTE result;
2274     
2275     if(!PyArg_ParseTuple(args,(char *)":StatusPort")) goto fail;
2276     result = (BYTE)StatusPort();
2277     
2278     resultobj = SWIG_From_unsigned_SS_char((unsigned char)result);
2279     return resultobj;
2280     fail:
2281     return NULL;
2282 }
2283
2284
2285 static PyObject *_wrap_SetExt(PyObject *self, PyObject *args) {
2286     PyObject *resultobj;
2287     int arg1 ;
2288     PyObject * obj0 = 0 ;
2289     
2290     if(!PyArg_ParseTuple(args,(char *)"O:SetExt",&obj0)) goto fail;
2291     arg1 = (int)SWIG_As_int(obj0); 
2292     if (PyErr_Occurred()) SWIG_fail;
2293     SetExt((ExtPin )arg1);
2294     
2295     Py_INCREF(Py_None); resultobj = Py_None;
2296     return resultobj;
2297     fail:
2298     return NULL;
2299 }
2300
2301
2302 static PyObject *_wrap_ResExt(PyObject *self, PyObject *args) {
2303     PyObject *resultobj;
2304     int arg1 ;
2305     PyObject * obj0 = 0 ;
2306     
2307     if(!PyArg_ParseTuple(args,(char *)"O:ResExt",&obj0)) goto fail;
2308     arg1 = (int)SWIG_As_int(obj0); 
2309     if (PyErr_Occurred()) SWIG_fail;
2310     ResExt((ExtPin )arg1);
2311     
2312     Py_INCREF(Py_None); resultobj = Py_None;
2313     return resultobj;
2314     fail:
2315     return NULL;
2316 }
2317
2318
2319 static PyObject *_wrap_PinValue(PyObject *self, PyObject *args) {
2320     PyObject *resultobj;
2321     int arg1 ;
2322     BOOL result;
2323     PyObject * obj0 = 0 ;
2324     
2325     if(!PyArg_ParseTuple(args,(char *)"O:PinValue",&obj0)) goto fail;
2326     arg1 = (int)SWIG_As_int(obj0); 
2327     if (PyErr_Occurred()) SWIG_fail;
2328     result = (BOOL)PinValue((ExtPin )arg1);
2329     
2330     resultobj = SWIG_From_int((int)result);
2331     return resultobj;
2332     fail:
2333     return NULL;
2334 }
2335
2336
2337 static PyObject *_wrap_SetBPF(PyObject *self, PyObject *args) {
2338     PyObject *resultobj;
2339     double arg1 ;
2340     PyObject * obj0 = 0 ;
2341     
2342     if(!PyArg_ParseTuple(args,(char *)"O:SetBPF",&obj0)) goto fail;
2343     arg1 = (double)SWIG_As_double(obj0); 
2344     if (PyErr_Occurred()) SWIG_fail;
2345     SetBPF(arg1);
2346     
2347     Py_INCREF(Py_None); resultobj = Py_None;
2348     return resultobj;
2349     fail:
2350     return NULL;
2351 }
2352
2353
2354 static PyObject *_wrap_TestPort(PyObject *self, PyObject *args) {
2355     PyObject *resultobj;
2356     
2357     if(!PyArg_ParseTuple(args,(char *)":TestPort")) goto fail;
2358     TestPort();
2359     
2360     Py_INCREF(Py_None); resultobj = Py_None;
2361     return resultobj;
2362     fail:
2363     return NULL;
2364 }
2365
2366
2367 static PyObject *_wrap_RCKStrobe(PyObject *self, PyObject *args) {
2368     PyObject *resultobj;
2369     BOOL arg1 ;
2370     int arg2 ;
2371     PyObject * obj0 = 0 ;
2372     PyObject * obj1 = 0 ;
2373     
2374     if(!PyArg_ParseTuple(args,(char *)"OO:RCKStrobe",&obj0,&obj1)) goto fail;
2375     arg1 = (BOOL)SWIG_As_int(obj0); 
2376     if (PyErr_Occurred()) SWIG_fail;
2377     arg2 = (int)SWIG_As_int(obj1); 
2378     if (PyErr_Occurred()) SWIG_fail;
2379     RCKStrobe(arg1,(RFE_RCK )arg2);
2380     
2381     Py_INCREF(Py_None); resultobj = Py_None;
2382     return resultobj;
2383     fail:
2384     return NULL;
2385 }
2386
2387
2388 static PyObject *_wrap_SRLoad(PyObject *self, PyObject *args) {
2389     PyObject *resultobj;
2390     int arg1 ;
2391     int arg2 ;
2392     PyObject * obj0 = 0 ;
2393     PyObject * obj1 = 0 ;
2394     
2395     if(!PyArg_ParseTuple(args,(char *)"OO:SRLoad",&obj0,&obj1)) goto fail;
2396     arg1 = (int)SWIG_As_int(obj0); 
2397     if (PyErr_Occurred()) SWIG_fail;
2398     arg2 = (int)SWIG_As_int(obj1); 
2399     if (PyErr_Occurred()) SWIG_fail;
2400     SRLoad((RFE_RCK )arg1,arg2);
2401     
2402     Py_INCREF(Py_None); resultobj = Py_None;
2403     return resultobj;
2404     fail:
2405     return NULL;
2406 }
2407
2408
2409 static PyObject *_wrap_ResetRFE(PyObject *self, PyObject *args) {
2410     PyObject *resultobj;
2411     
2412     if(!PyArg_ParseTuple(args,(char *)":ResetRFE")) goto fail;
2413     ResetRFE();
2414     
2415     Py_INCREF(Py_None); resultobj = Py_None;
2416     return resultobj;
2417     fail:
2418     return NULL;
2419 }
2420
2421
2422 static PyObject *_wrap_PA_SetLPF(PyObject *self, PyObject *args) {
2423     PyObject *resultobj;
2424     int arg1 ;
2425     PyObject * obj0 = 0 ;
2426     
2427     if(!PyArg_ParseTuple(args,(char *)"O:PA_SetLPF",&obj0)) goto fail;
2428     arg1 = (int)SWIG_As_int(obj0); 
2429     if (PyErr_Occurred()) SWIG_fail;
2430     PA_SetLPF(arg1);
2431     
2432     Py_INCREF(Py_None); resultobj = Py_None;
2433     return resultobj;
2434     fail:
2435     return NULL;
2436 }
2437
2438
2439 static PyObject *_wrap_PA_GetADC(PyObject *self, PyObject *args) {
2440     PyObject *resultobj;
2441     int arg1 ;
2442     BYTE result;
2443     PyObject * obj0 = 0 ;
2444     
2445     if(!PyArg_ParseTuple(args,(char *)"O:PA_GetADC",&obj0)) goto fail;
2446     arg1 = (int)SWIG_As_int(obj0); 
2447     if (PyErr_Occurred()) SWIG_fail;
2448     result = (BYTE)PA_GetADC(arg1);
2449     
2450     resultobj = SWIG_From_unsigned_SS_char((unsigned char)result);
2451     return resultobj;
2452     fail:
2453     return NULL;
2454 }
2455
2456
2457 static PyObject *_wrap_PA_ATUTune(PyObject *self, PyObject *args) {
2458     PyObject *resultobj;
2459     int arg1 ;
2460     BOOL result;
2461     PyObject * obj0 = 0 ;
2462     
2463     if(!PyArg_ParseTuple(args,(char *)"O:PA_ATUTune",&obj0)) goto fail;
2464     arg1 = (int)SWIG_As_int(obj0); 
2465     if (PyErr_Occurred()) SWIG_fail;
2466     result = (BOOL)PA_ATUTune((ATUTuneMode )arg1);
2467     
2468     resultobj = SWIG_From_int((int)result);
2469     return resultobj;
2470     fail:
2471     return NULL;
2472 }
2473
2474
2475 static PyObject *_wrap_getEnableLPF0(PyObject *self, PyObject *args) {
2476     PyObject *resultobj;
2477     BOOL result;
2478     
2479     if(!PyArg_ParseTuple(args,(char *)":getEnableLPF0")) goto fail;
2480     result = (BOOL)getEnableLPF0();
2481     
2482     resultobj = SWIG_From_int((int)result);
2483     return resultobj;
2484     fail:
2485     return NULL;
2486 }
2487
2488
2489 static PyObject *_wrap_setEnableLPF0(PyObject *self, PyObject *args) {
2490     PyObject *resultobj;
2491     BOOL arg1 ;
2492     PyObject * obj0 = 0 ;
2493     
2494     if(!PyArg_ParseTuple(args,(char *)"O:setEnableLPF0",&obj0)) goto fail;
2495     arg1 = (BOOL)SWIG_As_int(obj0); 
2496     if (PyErr_Occurred()) SWIG_fail;
2497     setEnableLPF0(arg1);
2498     
2499     Py_INCREF(Py_None); resultobj = Py_None;
2500     return resultobj;
2501     fail:
2502     return NULL;
2503 }
2504
2505
2506 static PyObject *_wrap_getExtended(PyObject *self, PyObject *args) {
2507     PyObject *resultobj;
2508     BOOL result;
2509     
2510     if(!PyArg_ParseTuple(args,(char *)":getExtended")) goto fail;
2511     result = (BOOL)getExtended();
2512     
2513     resultobj = SWIG_From_int((int)result);
2514     return resultobj;
2515     fail:
2516     return NULL;
2517 }
2518
2519
2520 static PyObject *_wrap_setExtended(PyObject *self, PyObject *args) {
2521     PyObject *resultobj;
2522     BOOL arg1 ;
2523     PyObject * obj0 = 0 ;
2524     
2525     if(!PyArg_ParseTuple(args,(char *)"O:setExtended",&obj0)) goto fail;
2526     arg1 = (BOOL)SWIG_As_int(obj0); 
2527     if (PyErr_Occurred()) SWIG_fail;
2528     setExtended(arg1);
2529     
2530     Py_INCREF(Py_None); resultobj = Py_None;
2531     return resultobj;
2532     fail:
2533     return NULL;
2534 }
2535
2536
2537 static PyObject *_wrap_getX2Enabled(PyObject *self, PyObject *args) {
2538     PyObject *resultobj;
2539     BOOL result;
2540     
2541     if(!PyArg_ParseTuple(args,(char *)":getX2Enabled")) goto fail;
2542     result = (BOOL)getX2Enabled();
2543     
2544     resultobj = SWIG_From_int((int)result);
2545     return resultobj;
2546     fail:
2547     return NULL;
2548 }
2549
2550
2551 static PyObject *_wrap_setX2Enabled(PyObject *self, PyObject *args) {
2552     PyObject *resultobj;
2553     BOOL arg1 ;
2554     PyObject * obj0 = 0 ;
2555     
2556     if(!PyArg_ParseTuple(args,(char *)"O:setX2Enabled",&obj0)) goto fail;
2557     arg1 = (BOOL)SWIG_As_int(obj0); 
2558     if (PyErr_Occurred()) SWIG_fail;
2559     setX2Enabled(arg1);
2560     
2561     Py_INCREF(Py_None); resultobj = Py_None;
2562     return resultobj;
2563     fail:
2564     return NULL;
2565 }
2566
2567
2568 static PyObject *_wrap_getX2Delay(PyObject *self, PyObject *args) {
2569     PyObject *resultobj;
2570     int result;
2571     
2572     if(!PyArg_ParseTuple(args,(char *)":getX2Delay")) goto fail;
2573     result = (int)getX2Delay();
2574     
2575     resultobj = SWIG_From_int((int)result);
2576     return resultobj;
2577     fail:
2578     return NULL;
2579 }
2580
2581
2582 static PyObject *_wrap_setX2Delay(PyObject *self, PyObject *args) {
2583     PyObject *resultobj;
2584     int arg1 ;
2585     PyObject * obj0 = 0 ;
2586     
2587     if(!PyArg_ParseTuple(args,(char *)"O:setX2Delay",&obj0)) goto fail;
2588     arg1 = (int)SWIG_As_int(obj0); 
2589     if (PyErr_Occurred()) SWIG_fail;
2590     setX2Delay(arg1);
2591     
2592     Py_INCREF(Py_None); resultobj = Py_None;
2593     return resultobj;
2594     fail:
2595     return NULL;
2596 }
2597
2598
2599 static PyObject *_wrap_getRFE_Enabled(PyObject *self, PyObject *args) {
2600     PyObject *resultobj;
2601     BOOL result;
2602     
2603     if(!PyArg_ParseTuple(args,(char *)":getRFE_Enabled")) goto fail;
2604     result = (BOOL)getRFE_Enabled();
2605     
2606     resultobj = SWIG_From_int((int)result);
2607     return resultobj;
2608     fail:
2609     return NULL;
2610 }
2611
2612
2613 static PyObject *_wrap_setRFE_Enabled(PyObject *self, PyObject *args) {
2614     PyObject *resultobj;
2615     BOOL arg1 ;
2616     PyObject * obj0 = 0 ;
2617     
2618     if(!PyArg_ParseTuple(args,(char *)"O:setRFE_Enabled",&obj0)) goto fail;
2619     arg1 = (BOOL)SWIG_As_int(obj0); 
2620     if (PyErr_Occurred()) SWIG_fail;
2621     setRFE_Enabled(arg1);
2622     
2623     Py_INCREF(Py_None); resultobj = Py_None;
2624     return resultobj;
2625     fail:
2626     return NULL;
2627 }
2628
2629
2630 static PyObject *_wrap_getPA_Enabled(PyObject *self, PyObject *args) {
2631     PyObject *resultobj;
2632     BOOL result;
2633     
2634     if(!PyArg_ParseTuple(args,(char *)":getPA_Enabled")) goto fail;
2635     result = (BOOL)getPA_Enabled();
2636     
2637     resultobj = SWIG_From_int((int)result);
2638     return resultobj;
2639     fail:
2640     return NULL;
2641 }
2642
2643
2644 static PyObject *_wrap_setPA_Enabled(PyObject *self, PyObject *args) {
2645     PyObject *resultobj;
2646     BOOL arg1 ;
2647     PyObject * obj0 = 0 ;
2648     
2649     if(!PyArg_ParseTuple(args,(char *)"O:setPA_Enabled",&obj0)) goto fail;
2650     arg1 = (BOOL)SWIG_As_int(obj0); 
2651     if (PyErr_Occurred()) SWIG_fail;
2652     setPA_Enabled(arg1);
2653     
2654     Py_INCREF(Py_None); resultobj = Py_None;
2655     return resultobj;
2656     fail:
2657     return NULL;
2658 }
2659
2660
2661 static PyObject *_wrap_getXVTR_Enabled(PyObject *self, PyObject *args) {
2662     PyObject *resultobj;
2663     BOOL result;
2664     
2665     if(!PyArg_ParseTuple(args,(char *)":getXVTR_Enabled")) goto fail;
2666     result = (BOOL)getXVTR_Enabled();
2667     
2668     resultobj = SWIG_From_int((int)result);
2669     return resultobj;
2670     fail:
2671     return NULL;
2672 }
2673
2674
2675 static PyObject *_wrap_setXVTR_Enabled(PyObject *self, PyObject *args) {
2676     PyObject *resultobj;
2677     BOOL arg1 ;
2678     BOOL result;
2679     PyObject * obj0 = 0 ;
2680     
2681     if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_Enabled",&obj0)) goto fail;
2682     arg1 = (BOOL)SWIG_As_int(obj0); 
2683     if (PyErr_Occurred()) SWIG_fail;
2684     result = (BOOL)setXVTR_Enabled(arg1);
2685     
2686     resultobj = SWIG_From_int((int)result);
2687     return resultobj;
2688     fail:
2689     return NULL;
2690 }
2691
2692
2693 static PyObject *_wrap_getUSB_Enabled(PyObject *self, PyObject *args) {
2694     PyObject *resultobj;
2695     BOOL result;
2696     
2697     if(!PyArg_ParseTuple(args,(char *)":getUSB_Enabled")) goto fail;
2698     result = (BOOL)getUSB_Enabled();
2699     
2700     resultobj = SWIG_From_int((int)result);
2701     return resultobj;
2702     fail:
2703     return NULL;
2704 }
2705
2706
2707 static PyObject *_wrap_setUSB_Enabled(PyObject *self, PyObject *args) {
2708     PyObject *resultobj;
2709     BOOL arg1 ;
2710     PyObject * obj0 = 0 ;
2711     
2712     if(!PyArg_ParseTuple(args,(char *)"O:setUSB_Enabled",&obj0)) goto fail;
2713     arg1 = (BOOL)SWIG_As_int(obj0); 
2714     if (PyErr_Occurred()) SWIG_fail;
2715     setUSB_Enabled(arg1);
2716     
2717     Py_INCREF(Py_None); resultobj = Py_None;
2718     return resultobj;
2719     fail:
2720     return NULL;
2721 }
2722
2723
2724 static PyObject *_wrap_getCurrentXVTRTRMode(PyObject *self, PyObject *args) {
2725     PyObject *resultobj;
2726     int result;
2727     
2728     if(!PyArg_ParseTuple(args,(char *)":getCurrentXVTRTRMode")) goto fail;
2729     result = (int)getCurrentXVTRTRMode();
2730     
2731     resultobj = SWIG_From_int((int)result);
2732     return resultobj;
2733     fail:
2734     return NULL;
2735 }
2736
2737
2738 static PyObject *_wrap_setCurrentXVTRTRMode(PyObject *self, PyObject *args) {
2739     PyObject *resultobj;
2740     int arg1 ;
2741     PyObject * obj0 = 0 ;
2742     
2743     if(!PyArg_ParseTuple(args,(char *)"O:setCurrentXVTRTRMode",&obj0)) goto fail;
2744     arg1 = (int)SWIG_As_int(obj0); 
2745     if (PyErr_Occurred()) SWIG_fail;
2746     setCurrentXVTRTRMode((XVTRTRMode )arg1);
2747     
2748     Py_INCREF(Py_None); resultobj = Py_None;
2749     return resultobj;
2750     fail:
2751     return NULL;
2752 }
2753
2754
2755 static PyObject *_wrap_getLatchDelay(PyObject *self, PyObject *args) {
2756     PyObject *resultobj;
2757     int result;
2758     
2759     if(!PyArg_ParseTuple(args,(char *)":getLatchDelay")) goto fail;
2760     result = (int)getLatchDelay();
2761     
2762     resultobj = SWIG_From_int((int)result);
2763     return resultobj;
2764     fail:
2765     return NULL;
2766 }
2767
2768
2769 static PyObject *_wrap_setLatchDelay(PyObject *self, PyObject *args) {
2770     PyObject *resultobj;
2771     int arg1 ;
2772     PyObject * obj0 = 0 ;
2773     
2774     if(!PyArg_ParseTuple(args,(char *)"O:setLatchDelay",&obj0)) goto fail;
2775     arg1 = (int)SWIG_As_int(obj0); 
2776     if (PyErr_Occurred()) SWIG_fail;
2777     setLatchDelay(arg1);
2778     
2779     Py_INCREF(Py_None); resultobj = Py_None;
2780     return resultobj;
2781     fail:
2782     return NULL;
2783 }
2784
2785
2786 static PyObject *_wrap_getMinFreq(PyObject *self, PyObject *args) {
2787     PyObject *resultobj;
2788     double result;
2789     
2790     if(!PyArg_ParseTuple(args,(char *)":getMinFreq")) goto fail;
2791     result = (double)getMinFreq();
2792     
2793     resultobj = SWIG_From_double((double)result);
2794     return resultobj;
2795     fail:
2796     return NULL;
2797 }
2798
2799
2800 static PyObject *_wrap_getMaxFreq(PyObject *self, PyObject *args) {
2801     PyObject *resultobj;
2802     double result;
2803     
2804     if(!PyArg_ParseTuple(args,(char *)":getMaxFreq")) goto fail;
2805     result = (double)getMaxFreq();
2806     
2807     resultobj = SWIG_From_double((double)result);
2808     return resultobj;
2809     fail:
2810     return NULL;
2811 }
2812
2813
2814 static PyObject *_wrap_getBaseAddr(PyObject *self, PyObject *args) {
2815     PyObject *resultobj;
2816     u_short result;
2817     
2818     if(!PyArg_ParseTuple(args,(char *)":getBaseAddr")) goto fail;
2819     result = getBaseAddr();
2820     
2821     {
2822         u_short * resultptr;
2823         resultptr = (u_short *) malloc(sizeof(u_short));
2824         memmove(resultptr, &result, sizeof(u_short));
2825         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1);
2826     }
2827     return resultobj;
2828     fail:
2829     return NULL;
2830 }
2831
2832
2833 static PyObject *_wrap_setBaseAddr(PyObject *self, PyObject *args) {
2834     PyObject *resultobj;
2835     u_short arg1 ;
2836     u_short result;
2837     u_short *argp1 ;
2838     PyObject * obj0 = 0 ;
2839     
2840     if(!PyArg_ParseTuple(args,(char *)"O:setBaseAddr",&obj0)) goto fail;
2841     if ((SWIG_ConvertPtr(obj0,(void **)(&argp1),SWIGTYPE_p_u_short,
2842     SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
2843     arg1 = *argp1;
2844     result = setBaseAddr(arg1);
2845     
2846     {
2847         u_short * resultptr;
2848         resultptr = (u_short *) malloc(sizeof(u_short));
2849         memmove(resultptr, &result, sizeof(u_short));
2850         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1);
2851     }
2852     return resultobj;
2853     fail:
2854     return NULL;
2855 }
2856
2857
2858 static PyObject *_wrap_getBandRelay(PyObject *self, PyObject *args) {
2859     PyObject *resultobj;
2860     int result;
2861     
2862     if(!PyArg_ParseTuple(args,(char *)":getBandRelay")) goto fail;
2863     result = (int)getBandRelay();
2864     
2865     resultobj = SWIG_From_int((int)result);
2866     return resultobj;
2867     fail:
2868     return NULL;
2869 }
2870
2871
2872 static PyObject *_wrap_setBandRelay(PyObject *self, PyObject *args) {
2873     PyObject *resultobj;
2874     int arg1 ;
2875     PyObject * obj0 = 0 ;
2876     
2877     if(!PyArg_ParseTuple(args,(char *)"O:setBandRelay",&obj0)) goto fail;
2878     arg1 = (int)SWIG_As_int(obj0); 
2879     if (PyErr_Occurred()) SWIG_fail;
2880     setBandRelay((BandSetting )arg1);
2881     
2882     Py_INCREF(Py_None); resultobj = Py_None;
2883     return resultobj;
2884     fail:
2885     return NULL;
2886 }
2887
2888
2889 static PyObject *_wrap_getTransmitRelay(PyObject *self, PyObject *args) {
2890     PyObject *resultobj;
2891     BOOL result;
2892     
2893     if(!PyArg_ParseTuple(args,(char *)":getTransmitRelay")) goto fail;
2894     result = (BOOL)getTransmitRelay();
2895     
2896     resultobj = SWIG_From_int((int)result);
2897     return resultobj;
2898     fail:
2899     return NULL;
2900 }
2901
2902
2903 static PyObject *_wrap_setTransmitRelay(PyObject *self, PyObject *args) {
2904     PyObject *resultobj;
2905     BOOL arg1 ;
2906     PyObject * obj0 = 0 ;
2907     
2908     if(!PyArg_ParseTuple(args,(char *)"O:setTransmitRelay",&obj0)) goto fail;
2909     arg1 = (BOOL)SWIG_As_int(obj0); 
2910     if (PyErr_Occurred()) SWIG_fail;
2911     setTransmitRelay(arg1);
2912     
2913     Py_INCREF(Py_None); resultobj = Py_None;
2914     return resultobj;
2915     fail:
2916     return NULL;
2917 }
2918
2919
2920 static PyObject *_wrap_getMuteRelay(PyObject *self, PyObject *args) {
2921     PyObject *resultobj;
2922     BOOL result;
2923     
2924     if(!PyArg_ParseTuple(args,(char *)":getMuteRelay")) goto fail;
2925     result = (BOOL)getMuteRelay();
2926     
2927     resultobj = SWIG_From_int((int)result);
2928     return resultobj;
2929     fail:
2930     return NULL;
2931 }
2932
2933
2934 static PyObject *_wrap_setMuteRelay(PyObject *self, PyObject *args) {
2935     PyObject *resultobj;
2936     BOOL arg1 ;
2937     PyObject * obj0 = 0 ;
2938     
2939     if(!PyArg_ParseTuple(args,(char *)"O:setMuteRelay",&obj0)) goto fail;
2940     arg1 = (BOOL)SWIG_As_int(obj0); 
2941     if (PyErr_Occurred()) SWIG_fail;
2942     setMuteRelay(arg1);
2943     
2944     Py_INCREF(Py_None); resultobj = Py_None;
2945     return resultobj;
2946     fail:
2947     return NULL;
2948 }
2949
2950
2951 static PyObject *_wrap_getGainRelay(PyObject *self, PyObject *args) {
2952     PyObject *resultobj;
2953     BOOL result;
2954     
2955     if(!PyArg_ParseTuple(args,(char *)":getGainRelay")) goto fail;
2956     result = (BOOL)getGainRelay();
2957     
2958     resultobj = SWIG_From_int((int)result);
2959     return resultobj;
2960     fail:
2961     return NULL;
2962 }
2963
2964
2965 static PyObject *_wrap_setGainRelay(PyObject *self, PyObject *args) {
2966     PyObject *resultobj;
2967     BOOL arg1 ;
2968     PyObject * obj0 = 0 ;
2969     
2970     if(!PyArg_ParseTuple(args,(char *)"O:setGainRelay",&obj0)) goto fail;
2971     arg1 = (BOOL)SWIG_As_int(obj0); 
2972     if (PyErr_Occurred()) SWIG_fail;
2973     setGainRelay(arg1);
2974     
2975     Py_INCREF(Py_None); resultobj = Py_None;
2976     return resultobj;
2977     fail:
2978     return NULL;
2979 }
2980
2981
2982 static PyObject *_wrap_getExternalOutput(PyObject *self, PyObject *args) {
2983     PyObject *resultobj;
2984     int result;
2985     
2986     if(!PyArg_ParseTuple(args,(char *)":getExternalOutput")) goto fail;
2987     result = (int)getExternalOutput();
2988     
2989     resultobj = SWIG_From_int((int)result);
2990     return resultobj;
2991     fail:
2992     return NULL;
2993 }
2994
2995
2996 static PyObject *_wrap_setExternalOutput(PyObject *self, PyObject *args) {
2997     PyObject *resultobj;
2998     int arg1 ;
2999     PyObject * obj0 = 0 ;
3000     
3001     if(!PyArg_ParseTuple(args,(char *)"O:setExternalOutput",&obj0)) goto fail;
3002     arg1 = (int)SWIG_As_int(obj0); 
3003     if (PyErr_Occurred()) SWIG_fail;
3004     setExternalOutput(arg1);
3005     
3006     Py_INCREF(Py_None); resultobj = Py_None;
3007     return resultobj;
3008     fail:
3009     return NULL;
3010 }
3011
3012
3013 static PyObject *_wrap_getDDSClockCorrection(PyObject *self, PyObject *args) {
3014     PyObject *resultobj;
3015     double result;
3016     
3017     if(!PyArg_ParseTuple(args,(char *)":getDDSClockCorrection")) goto fail;
3018     result = (double)getDDSClockCorrection();
3019     
3020     resultobj = SWIG_From_double((double)result);
3021     return resultobj;
3022     fail:
3023     return NULL;
3024 }
3025
3026
3027 static PyObject *_wrap_setDDSClockCorrection(PyObject *self, PyObject *args) {
3028     PyObject *resultobj;
3029     double arg1 ;
3030     PyObject * obj0 = 0 ;
3031     
3032     if(!PyArg_ParseTuple(args,(char *)"O:setDDSClockCorrection",&obj0)) goto fail;
3033     arg1 = (double)SWIG_As_double(obj0); 
3034     if (PyErr_Occurred()) SWIG_fail;
3035     setDDSClockCorrection(arg1);
3036     
3037     Py_INCREF(Py_None); resultobj = Py_None;
3038     return resultobj;
3039     fail:
3040     return NULL;
3041 }
3042
3043
3044 static PyObject *_wrap_getPLLMult(PyObject *self, PyObject *args) {
3045     PyObject *resultobj;
3046     int result;
3047     
3048     if(!PyArg_ParseTuple(args,(char *)":getPLLMult")) goto fail;
3049     result = (int)getPLLMult();
3050     
3051     resultobj = SWIG_From_int((int)result);
3052     return resultobj;
3053     fail:
3054     return NULL;
3055 }
3056
3057
3058 static PyObject *_wrap_setPLLMult(PyObject *self, PyObject *args) {
3059     PyObject *resultobj;
3060     int arg1 ;
3061     PyObject * obj0 = 0 ;
3062     
3063     if(!PyArg_ParseTuple(args,(char *)"O:setPLLMult",&obj0)) goto fail;
3064     arg1 = (int)SWIG_As_int(obj0); 
3065     if (PyErr_Occurred()) SWIG_fail;
3066     setPLLMult(arg1);
3067     
3068     Py_INCREF(Py_None); resultobj = Py_None;
3069     return resultobj;
3070     fail:
3071     return NULL;
3072 }
3073
3074
3075 static PyObject *_wrap_getDDSClock(PyObject *self, PyObject *args) {
3076     PyObject *resultobj;
3077     double result;
3078     
3079     if(!PyArg_ParseTuple(args,(char *)":getDDSClock")) goto fail;
3080     result = (double)getDDSClock();
3081     
3082     resultobj = SWIG_From_double((double)result);
3083     return resultobj;
3084     fail:
3085     return NULL;
3086 }
3087
3088
3089 static PyObject *_wrap_setDDSClock(PyObject *self, PyObject *args) {
3090     PyObject *resultobj;
3091     double arg1 ;
3092     PyObject * obj0 = 0 ;
3093     
3094     if(!PyArg_ParseTuple(args,(char *)"O:setDDSClock",&obj0)) goto fail;
3095     arg1 = (double)SWIG_As_double(obj0); 
3096     if (PyErr_Occurred()) SWIG_fail;
3097     setDDSClock(arg1);
3098     
3099     Py_INCREF(Py_None); resultobj = Py_None;
3100     return resultobj;
3101     fail:
3102     return NULL;
3103 }
3104
3105
3106 static PyObject *_wrap_getIFShift(PyObject *self, PyObject *args) {
3107     PyObject *resultobj;
3108     BOOL result;
3109     
3110     if(!PyArg_ParseTuple(args,(char *)":getIFShift")) goto fail;
3111     result = (BOOL)getIFShift();
3112     
3113     resultobj = SWIG_From_int((int)result);
3114     return resultobj;
3115     fail:
3116     return NULL;
3117 }
3118
3119
3120 static PyObject *_wrap_setIFShift(PyObject *self, PyObject *args) {
3121     PyObject *resultobj;
3122     BOOL arg1 ;
3123     PyObject * obj0 = 0 ;
3124     
3125     if(!PyArg_ParseTuple(args,(char *)"O:setIFShift",&obj0)) goto fail;
3126     arg1 = (BOOL)SWIG_As_int(obj0); 
3127     if (PyErr_Occurred()) SWIG_fail;
3128     setIFShift(arg1);
3129     
3130     Py_INCREF(Py_None); resultobj = Py_None;
3131     return resultobj;
3132     fail:
3133     return NULL;
3134 }
3135
3136
3137 static PyObject *_wrap_getSpurReduction(PyObject *self, PyObject *args) {
3138     PyObject *resultobj;
3139     BOOL result;
3140     
3141     if(!PyArg_ParseTuple(args,(char *)":getSpurReduction")) goto fail;
3142     result = (BOOL)getSpurReduction();
3143     
3144     resultobj = SWIG_From_int((int)result);
3145     return resultobj;
3146     fail:
3147     return NULL;
3148 }
3149
3150
3151 static PyObject *_wrap_setSpurReduction(PyObject *self, PyObject *args) {
3152     PyObject *resultobj;
3153     BOOL arg1 ;
3154     BOOL result;
3155     PyObject * obj0 = 0 ;
3156     
3157     if(!PyArg_ParseTuple(args,(char *)"O:setSpurReduction",&obj0)) goto fail;
3158     arg1 = (BOOL)SWIG_As_int(obj0); 
3159     if (PyErr_Occurred()) SWIG_fail;
3160     result = (BOOL)setSpurReduction(arg1);
3161     
3162     resultobj = SWIG_From_int((int)result);
3163     return resultobj;
3164     fail:
3165     return NULL;
3166 }
3167
3168
3169 static PyObject *_wrap_getIFFreq(PyObject *self, PyObject *args) {
3170     PyObject *resultobj;
3171     double result;
3172     
3173     if(!PyArg_ParseTuple(args,(char *)":getIFFreq")) goto fail;
3174     result = (double)getIFFreq();
3175     
3176     resultobj = SWIG_From_double((double)result);
3177     return resultobj;
3178     fail:
3179     return NULL;
3180 }
3181
3182
3183 static PyObject *_wrap_setIFFreq(PyObject *self, PyObject *args) {
3184     PyObject *resultobj;
3185     double arg1 ;
3186     PyObject * obj0 = 0 ;
3187     
3188     if(!PyArg_ParseTuple(args,(char *)"O:setIFFreq",&obj0)) goto fail;
3189     arg1 = (double)SWIG_As_double(obj0); 
3190     if (PyErr_Occurred()) SWIG_fail;
3191     setIFFreq(arg1);
3192     
3193     Py_INCREF(Py_None); resultobj = Py_None;
3194     return resultobj;
3195     fail:
3196     return NULL;
3197 }
3198
3199
3200 static PyObject *_wrap_getDDSFreq(PyObject *self, PyObject *args) {
3201     PyObject *resultobj;
3202     double result;
3203     
3204     if(!PyArg_ParseTuple(args,(char *)":getDDSFreq")) goto fail;
3205     result = (double)getDDSFreq();
3206     
3207     resultobj = SWIG_From_double((double)result);
3208     return resultobj;
3209     fail:
3210     return NULL;
3211 }
3212
3213
3214 static PyObject *_wrap_setDDSFreq(PyObject *self, PyObject *args) {
3215     PyObject *resultobj;
3216     double arg1 ;
3217     PyObject * obj0 = 0 ;
3218     
3219     if(!PyArg_ParseTuple(args,(char *)"O:setDDSFreq",&obj0)) goto fail;
3220     arg1 = (double)SWIG_As_double(obj0); 
3221     if (PyErr_Occurred()) SWIG_fail;
3222     setDDSFreq(arg1);
3223     
3224     Py_INCREF(Py_None); resultobj = Py_None;
3225     return resultobj;
3226     fail:
3227     return NULL;
3228 }
3229
3230
3231 static PyObject *_wrap_getSampleRate(PyObject *self, PyObject *args) {
3232     PyObject *resultobj;
3233     int result;
3234     
3235     if(!PyArg_ParseTuple(args,(char *)":getSampleRate")) goto fail;
3236     result = (int)getSampleRate();
3237     
3238     resultobj = SWIG_From_int((int)result);
3239     return resultobj;
3240     fail:
3241     return NULL;
3242 }
3243
3244
3245 static PyObject *_wrap_setSampleRate(PyObject *self, PyObject *args) {
3246     PyObject *resultobj;
3247     int arg1 ;
3248     PyObject * obj0 = 0 ;
3249     
3250     if(!PyArg_ParseTuple(args,(char *)"O:setSampleRate",&obj0)) goto fail;
3251     arg1 = (int)SWIG_As_int(obj0); 
3252     if (PyErr_Occurred()) SWIG_fail;
3253     setSampleRate(arg1);
3254     
3255     Py_INCREF(Py_None); resultobj = Py_None;
3256     return resultobj;
3257     fail:
3258     return NULL;
3259 }
3260
3261
3262 static PyObject *_wrap_getFFTLength(PyObject *self, PyObject *args) {
3263     PyObject *resultobj;
3264     int result;
3265     
3266     if(!PyArg_ParseTuple(args,(char *)":getFFTLength")) goto fail;
3267     result = (int)getFFTLength();
3268     
3269     resultobj = SWIG_From_int((int)result);
3270     return resultobj;
3271     fail:
3272     return NULL;
3273 }
3274
3275
3276 static PyObject *_wrap_setFFTLength(PyObject *self, PyObject *args) {
3277     PyObject *resultobj;
3278     int arg1 ;
3279     PyObject * obj0 = 0 ;
3280     
3281     if(!PyArg_ParseTuple(args,(char *)"O:setFFTLength",&obj0)) goto fail;
3282     arg1 = (int)SWIG_As_int(obj0); 
3283     if (PyErr_Occurred()) SWIG_fail;
3284     setFFTLength(arg1);
3285     
3286     Py_INCREF(Py_None); resultobj = Py_None;
3287     return resultobj;
3288     fail:
3289     return NULL;
3290 }
3291
3292
3293 static PyObject *_wrap_getTuneFFT(PyObject *self, PyObject *args) {
3294     PyObject *resultobj;
3295     int result;
3296     
3297     if(!PyArg_ParseTuple(args,(char *)":getTuneFFT")) goto fail;
3298     result = (int)getTuneFFT();
3299     
3300     resultobj = SWIG_From_int((int)result);
3301     return resultobj;
3302     fail:
3303     return NULL;
3304 }
3305
3306
3307 static PyObject *_wrap_getTuneFracRel(PyObject *self, PyObject *args) {
3308     PyObject *resultobj;
3309     double result;
3310     
3311     if(!PyArg_ParseTuple(args,(char *)":getTuneFracRel")) goto fail;
3312     result = (double)getTuneFracRel();
3313     
3314     resultobj = SWIG_From_double((double)result);
3315     return resultobj;
3316     fail:
3317     return NULL;
3318 }
3319
3320
3321 static PyObject *_wrap_getVFOOffset(PyObject *self, PyObject *args) {
3322     PyObject *resultobj;
3323     double result;
3324     
3325     if(!PyArg_ParseTuple(args,(char *)":getVFOOffset")) goto fail;
3326     result = (double)getVFOOffset();
3327     
3328     resultobj = SWIG_From_double((double)result);
3329     return resultobj;
3330     fail:
3331     return NULL;
3332 }
3333
3334
3335 static PyObject *_wrap_setVFOOffset(PyObject *self, PyObject *args) {
3336     PyObject *resultobj;
3337     double arg1 ;
3338     PyObject * obj0 = 0 ;
3339     
3340     if(!PyArg_ParseTuple(args,(char *)"O:setVFOOffset",&obj0)) goto fail;
3341     arg1 = (double)SWIG_As_double(obj0); 
3342     if (PyErr_Occurred()) SWIG_fail;
3343     setVFOOffset(arg1);
3344     
3345     Py_INCREF(Py_None); resultobj = Py_None;
3346     return resultobj;
3347     fail:
3348     return NULL;
3349 }
3350
3351
3352 static PyObject *_wrap_getIOUDClock(PyObject *self, PyObject *args) {
3353     PyObject *resultobj;
3354     int result;
3355     
3356     if(!PyArg_ParseTuple(args,(char *)":getIOUDClock")) goto fail;
3357     result = (int)getIOUDClock();
3358     
3359     resultobj = SWIG_From_int((int)result);
3360     return resultobj;
3361     fail:
3362     return NULL;
3363 }
3364
3365
3366 static PyObject *_wrap_setIOUDClock(PyObject *self, PyObject *args) {
3367     PyObject *resultobj;
3368     int arg1 ;
3369     PyObject * obj0 = 0 ;
3370     
3371     if(!PyArg_ParseTuple(args,(char *)"O:setIOUDClock",&obj0)) goto fail;
3372     arg1 = (int)SWIG_As_int(obj0); 
3373     if (PyErr_Occurred()) SWIG_fail;
3374     setIOUDClock(arg1);
3375     
3376     Py_INCREF(Py_None); resultobj = Py_None;
3377     return resultobj;
3378     fail:
3379     return NULL;
3380 }
3381
3382
3383 static PyObject *_wrap_getDACMult(PyObject *self, PyObject *args) {
3384     PyObject *resultobj;
3385     u_short result;
3386     
3387     if(!PyArg_ParseTuple(args,(char *)":getDACMult")) goto fail;
3388     result = getDACMult();
3389     
3390     {
3391         u_short * resultptr;
3392         resultptr = (u_short *) malloc(sizeof(u_short));
3393         memmove(resultptr, &result, sizeof(u_short));
3394         resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_u_short, 1);
3395     }
3396     return resultobj;
3397     fail:
3398     return NULL;
3399 }
3400
3401
3402 static PyObject *_wrap_setDACMult(PyObject *self, PyObject *args) {
3403     PyObject *resultobj;
3404     u_short arg1 ;
3405     u_short *argp1 ;
3406     PyObject * obj0 = 0 ;
3407     
3408     if(!PyArg_ParseTuple(args,(char *)"O:setDACMult",&obj0)) goto fail;
3409     if ((SWIG_ConvertPtr(obj0,(void **)(&argp1),SWIGTYPE_p_u_short,
3410     SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
3411     arg1 = *argp1;
3412     setDACMult(arg1);
3413     
3414     Py_INCREF(Py_None); resultobj = Py_None;
3415     return resultobj;
3416     fail:
3417     return NULL;
3418 }
3419
3420
3421 static PyObject *_wrap_getAMP_Relay(PyObject *self, PyObject *args) {
3422     PyObject *resultobj;
3423     BOOL result;
3424     
3425     if(!PyArg_ParseTuple(args,(char *)":getAMP_Relay")) goto fail;
3426     result = (BOOL)getAMP_Relay();
3427     
3428     resultobj = SWIG_From_int((int)result);
3429     return resultobj;
3430     fail:
3431     return NULL;
3432 }
3433
3434
3435 static PyObject *_wrap_setAMP_Relay(PyObject *self, PyObject *args) {
3436     PyObject *resultobj;
3437     BOOL arg1 ;
3438     BOOL result;
3439     PyObject * obj0 = 0 ;
3440     
3441     if(!PyArg_ParseTuple(args,(char *)"O:setAMP_Relay",&obj0)) goto fail;
3442     arg1 = (BOOL)SWIG_As_int(obj0); 
3443     if (PyErr_Occurred()) SWIG_fail;
3444     result = (BOOL)setAMP_Relay(arg1);
3445     
3446     resultobj = SWIG_From_int((int)result);
3447     return resultobj;
3448     fail:
3449     return NULL;
3450 }
3451
3452
3453 static PyObject *_wrap_getATTN_Relay(PyObject *self, PyObject *args) {
3454     PyObject *resultobj;
3455     BOOL result;
3456     
3457     if(!PyArg_ParseTuple(args,(char *)":getATTN_Relay")) goto fail;
3458     result = (BOOL)getATTN_Relay();
3459     
3460     resultobj = SWIG_From_int((int)result);
3461     return resultobj;
3462     fail:
3463     return NULL;
3464 }
3465
3466
3467 static PyObject *_wrap_setATTN_Relay(PyObject *self, PyObject *args) {
3468     PyObject *resultobj;
3469     BOOL arg1 ;
3470     PyObject * obj0 = 0 ;
3471     
3472     if(!PyArg_ParseTuple(args,(char *)"O:setATTN_Relay",&obj0)) goto fail;
3473     arg1 = (BOOL)SWIG_As_int(obj0); 
3474     if (PyErr_Occurred()) SWIG_fail;
3475     setATTN_Relay(arg1);
3476     
3477     Py_INCREF(Py_None); resultobj = Py_None;
3478     return resultobj;
3479     fail:
3480     return NULL;
3481 }
3482
3483
3484 static PyObject *_wrap_getXVTR_TR_Relay(PyObject *self, PyObject *args) {
3485     PyObject *resultobj;
3486     BOOL result;
3487     
3488     if(!PyArg_ParseTuple(args,(char *)":getXVTR_TR_Relay")) goto fail;
3489     result = (BOOL)getXVTR_TR_Relay();
3490     
3491     resultobj = SWIG_From_int((int)result);
3492     return resultobj;
3493     fail:
3494     return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_setXVTR_TR_Relay(PyObject *self, PyObject *args) {
3499     PyObject *resultobj;
3500     BOOL arg1 ;
3501     BOOL result;
3502     PyObject * obj0 = 0 ;
3503     
3504     if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_TR_Relay",&obj0)) goto fail;
3505     arg1 = (BOOL)SWIG_As_int(obj0); 
3506     if (PyErr_Occurred()) SWIG_fail;
3507     result = (BOOL)setXVTR_TR_Relay(arg1);
3508     
3509     resultobj = SWIG_From_int((int)result);
3510     return resultobj;
3511     fail:
3512     return NULL;
3513 }
3514
3515
3516 static PyObject *_wrap_getXVTR_Relay(PyObject *self, PyObject *args) {
3517     PyObject *resultobj;
3518     BOOL result;
3519     
3520     if(!PyArg_ParseTuple(args,(char *)":getXVTR_Relay")) goto fail;
3521     result = (BOOL)getXVTR_Relay();
3522     
3523     resultobj = SWIG_From_int((int)result);
3524     return resultobj;
3525     fail:
3526     return NULL;
3527 }
3528
3529
3530 static PyObject *_wrap_setXVTR_Relay(PyObject *self, PyObject *args) {
3531     PyObject *resultobj;
3532     BOOL arg1 ;
3533     BOOL result;
3534     PyObject * obj0 = 0 ;
3535     
3536     if(!PyArg_ParseTuple(args,(char *)"O:setXVTR_Relay",&obj0)) goto fail;
3537     arg1 = (BOOL)SWIG_As_int(obj0); 
3538     if (PyErr_Occurred()) SWIG_fail;
3539     result = (BOOL)setXVTR_Relay(arg1);
3540     
3541     resultobj = SWIG_From_int((int)result);
3542     return resultobj;
3543     fail:
3544     return NULL;
3545 }
3546
3547
3548 static PyObject *_wrap_getIMPULSE_Relay(PyObject *self, PyObject *args) {
3549     PyObject *resultobj;
3550     BOOL result;
3551     
3552     if(!PyArg_ParseTuple(args,(char *)":getIMPULSE_Relay")) goto fail;
3553     result = (BOOL)getIMPULSE_Relay();
3554     
3555     resultobj = SWIG_From_int((int)result);
3556     return resultobj;
3557     fail:
3558     return NULL;
3559 }
3560
3561
3562 static PyObject *_wrap_setIMPULSE_Relay(PyObject *self, PyObject *args) {
3563     PyObject *resultobj;
3564     BOOL arg1 ;
3565     BOOL result;
3566     PyObject * obj0 = 0 ;
3567     
3568     if(!PyArg_ParseTuple(args,(char *)"O:setIMPULSE_Relay",&obj0)) goto fail;
3569     arg1 = (BOOL)SWIG_As_int(obj0); 
3570     if (PyErr_Occurred()) SWIG_fail;
3571     result = (BOOL)setIMPULSE_Relay(arg1);
3572     
3573     resultobj = SWIG_From_int((int)result);
3574     return resultobj;
3575     fail:
3576     return NULL;
3577 }
3578
3579
3580 static PyObject *_wrap_getPA_TransmitRelay(PyObject *self, PyObject *args) {
3581     PyObject *resultobj;
3582     BOOL result;
3583     
3584     if(!PyArg_ParseTuple(args,(char *)":getPA_TransmitRelay")) goto fail;
3585     result = (BOOL)getPA_TransmitRelay();
3586     
3587     resultobj = SWIG_From_int((int)result);
3588     return resultobj;
3589     fail:
3590     return NULL;
3591 }
3592
3593
3594 static PyObject *_wrap_setPA_TransmitRelay(PyObject *self, PyObject *args) {
3595     PyObject *resultobj;
3596     BOOL arg1 ;
3597     BOOL result;
3598     PyObject * obj0 = 0 ;
3599     
3600     if(!PyArg_ParseTuple(args,(char *)"O:setPA_TransmitRelay",&obj0)) goto fail;
3601     arg1 = (BOOL)SWIG_As_int(obj0); 
3602     if (PyErr_Occurred()) SWIG_fail;
3603     result = (BOOL)setPA_TransmitRelay(arg1);
3604     
3605     resultobj = SWIG_From_int((int)result);
3606     return resultobj;
3607     fail:
3608     return NULL;
3609 }
3610
3611
3612 static PyObject *_wrap_getPA_BiasOn(PyObject *self, PyObject *args) {
3613     PyObject *resultobj;
3614     BOOL result;
3615     
3616     if(!PyArg_ParseTuple(args,(char *)":getPA_BiasOn")) goto fail;
3617     result = (BOOL)getPA_BiasOn();
3618     
3619     resultobj = SWIG_From_int((int)result);
3620     return resultobj;
3621     fail:
3622     return NULL;
3623 }
3624
3625
3626 static PyObject *_wrap_setPA_BiasOn(PyObject *self, PyObject *args) {
3627     PyObject *resultobj;
3628     BOOL arg1 ;
3629     BOOL result;
3630     PyObject * obj0 = 0 ;
3631     
3632     if(!PyArg_ParseTuple(args,(char *)"O:setPA_BiasOn",&obj0)) goto fail;
3633     arg1 = (BOOL)SWIG_As_int(obj0); 
3634     if (PyErr_Occurred()) SWIG_fail;
3635     result = (BOOL)setPA_BiasOn(arg1);
3636     
3637     resultobj = SWIG_From_int((int)result);
3638     return resultobj;
3639     fail:
3640     return NULL;
3641 }
3642
3643
3644 static PyMethodDef SwigMethods[] = {
3645          { (char *)"openPort", _wrap_openPort, METH_VARARGS, NULL },
3646          { (char *)"closePort", _wrap_closePort, METH_VARARGS, NULL },
3647          { (char *)"USB_Sdr1kLatch", _wrap_USB_Sdr1kLatch, METH_VARARGS, NULL },
3648          { (char *)"USB_Sdr1kGetStatusPort", _wrap_USB_Sdr1kGetStatusPort, METH_VARARGS, NULL },
3649          { (char *)"USB_Sdr1kGetADC", _wrap_USB_Sdr1kGetADC, METH_VARARGS, NULL },
3650          { (char *)"USB_Sdr1kDDSReset", _wrap_USB_Sdr1kDDSReset, METH_VARARGS, NULL },
3651          { (char *)"USB_Sdr1kDDSWrite", _wrap_USB_Sdr1kDDSWrite, METH_VARARGS, NULL },
3652          { (char *)"USB_Sdr1kSRLoad", _wrap_USB_Sdr1kSRLoad, METH_VARARGS, NULL },
3653          { (char *)"DttSP_ChangeOsc", _wrap_DttSP_ChangeOsc, METH_VARARGS, NULL },
3654          { (char *)"Init", _wrap_Init, METH_VARARGS, NULL },
3655          { (char *)"PowerOn", _wrap_PowerOn, METH_VARARGS, NULL },
3656          { (char *)"StandBy", _wrap_StandBy, METH_VARARGS, NULL },
3657          { (char *)"Impulse", _wrap_Impulse, METH_VARARGS, NULL },
3658          { (char *)"StatusPort", _wrap_StatusPort, METH_VARARGS, NULL },
3659          { (char *)"SetExt", _wrap_SetExt, METH_VARARGS, NULL },
3660          { (char *)"ResExt", _wrap_ResExt, METH_VARARGS, NULL },
3661          { (char *)"PinValue", _wrap_PinValue, METH_VARARGS, NULL },
3662          { (char *)"SetBPF", _wrap_SetBPF, METH_VARARGS, NULL },
3663          { (char *)"TestPort", _wrap_TestPort, METH_VARARGS, NULL },
3664          { (char *)"RCKStrobe", _wrap_RCKStrobe, METH_VARARGS, NULL },
3665          { (char *)"SRLoad", _wrap_SRLoad, METH_VARARGS, NULL },
3666          { (char *)"ResetRFE", _wrap_ResetRFE, METH_VARARGS, NULL },
3667          { (char *)"PA_SetLPF", _wrap_PA_SetLPF, METH_VARARGS, NULL },
3668          { (char *)"PA_GetADC", _wrap_PA_GetADC, METH_VARARGS, NULL },
3669          { (char *)"PA_ATUTune", _wrap_PA_ATUTune, METH_VARARGS, NULL },
3670          { (char *)"getEnableLPF0", _wrap_getEnableLPF0, METH_VARARGS, NULL },
3671          { (char *)"setEnableLPF0", _wrap_setEnableLPF0, METH_VARARGS, NULL },
3672          { (char *)"getExtended", _wrap_getExtended, METH_VARARGS, NULL },
3673          { (char *)"setExtended", _wrap_setExtended, METH_VARARGS, NULL },
3674          { (char *)"getX2Enabled", _wrap_getX2Enabled, METH_VARARGS, NULL },
3675          { (char *)"setX2Enabled", _wrap_setX2Enabled, METH_VARARGS, NULL },
3676          { (char *)"getX2Delay", _wrap_getX2Delay, METH_VARARGS, NULL },
3677          { (char *)"setX2Delay", _wrap_setX2Delay, METH_VARARGS, NULL },
3678          { (char *)"getRFE_Enabled", _wrap_getRFE_Enabled, METH_VARARGS, NULL },
3679          { (char *)"setRFE_Enabled", _wrap_setRFE_Enabled, METH_VARARGS, NULL },
3680          { (char *)"getPA_Enabled", _wrap_getPA_Enabled, METH_VARARGS, NULL },
3681          { (char *)"setPA_Enabled", _wrap_setPA_Enabled, METH_VARARGS, NULL },
3682          { (char *)"getXVTR_Enabled", _wrap_getXVTR_Enabled, METH_VARARGS, NULL },
3683          { (char *)"setXVTR_Enabled", _wrap_setXVTR_Enabled, METH_VARARGS, NULL },
3684          { (char *)"getUSB_Enabled", _wrap_getUSB_Enabled, METH_VARARGS, NULL },
3685          { (char *)"setUSB_Enabled", _wrap_setUSB_Enabled, METH_VARARGS, NULL },
3686          { (char *)"getCurrentXVTRTRMode", _wrap_getCurrentXVTRTRMode, METH_VARARGS, NULL },
3687          { (char *)"setCurrentXVTRTRMode", _wrap_setCurrentXVTRTRMode, METH_VARARGS, NULL },
3688          { (char *)"getLatchDelay", _wrap_getLatchDelay, METH_VARARGS, NULL },
3689          { (char *)"setLatchDelay", _wrap_setLatchDelay, METH_VARARGS, NULL },
3690          { (char *)"getMinFreq", _wrap_getMinFreq, METH_VARARGS, NULL },
3691          { (char *)"getMaxFreq", _wrap_getMaxFreq, METH_VARARGS, NULL },
3692          { (char *)"getBaseAddr", _wrap_getBaseAddr, METH_VARARGS, NULL },
3693          { (char *)"setBaseAddr", _wrap_setBaseAddr, METH_VARARGS, NULL },
3694          { (char *)"getBandRelay", _wrap_getBandRelay, METH_VARARGS, NULL },
3695          { (char *)"setBandRelay", _wrap_setBandRelay, METH_VARARGS, NULL },
3696          { (char *)"getTransmitRelay", _wrap_getTransmitRelay, METH_VARARGS, NULL },
3697          { (char *)"setTransmitRelay", _wrap_setTransmitRelay, METH_VARARGS, NULL },
3698          { (char *)"getMuteRelay", _wrap_getMuteRelay, METH_VARARGS, NULL },
3699          { (char *)"setMuteRelay", _wrap_setMuteRelay, METH_VARARGS, NULL },
3700          { (char *)"getGainRelay", _wrap_getGainRelay, METH_VARARGS, NULL },
3701          { (char *)"setGainRelay", _wrap_setGainRelay, METH_VARARGS, NULL },
3702          { (char *)"getExternalOutput", _wrap_getExternalOutput, METH_VARARGS, NULL },
3703          { (char *)"setExternalOutput", _wrap_setExternalOutput, METH_VARARGS, NULL },
3704          { (char *)"getDDSClockCorrection", _wrap_getDDSClockCorrection, METH_VARARGS, NULL },
3705          { (char *)"setDDSClockCorrection", _wrap_setDDSClockCorrection, METH_VARARGS, NULL },
3706          { (char *)"getPLLMult", _wrap_getPLLMult, METH_VARARGS, NULL },
3707          { (char *)"setPLLMult", _wrap_setPLLMult, METH_VARARGS, NULL },
3708          { (char *)"getDDSClock", _wrap_getDDSClock, METH_VARARGS, NULL },
3709          { (char *)"setDDSClock", _wrap_setDDSClock, METH_VARARGS, NULL },
3710          { (char *)"getIFShift", _wrap_getIFShift, METH_VARARGS, NULL },
3711          { (char *)"setIFShift", _wrap_setIFShift, METH_VARARGS, NULL },
3712          { (char *)"getSpurReduction", _wrap_getSpurReduction, METH_VARARGS, NULL },
3713          { (char *)"setSpurReduction", _wrap_setSpurReduction, METH_VARARGS, NULL },
3714          { (char *)"getIFFreq", _wrap_getIFFreq, METH_VARARGS, NULL },
3715          { (char *)"setIFFreq", _wrap_setIFFreq, METH_VARARGS, NULL },
3716          { (char *)"getDDSFreq", _wrap_getDDSFreq, METH_VARARGS, NULL },
3717          { (char *)"setDDSFreq", _wrap_setDDSFreq, METH_VARARGS, NULL },
3718          { (char *)"getSampleRate", _wrap_getSampleRate, METH_VARARGS, NULL },
3719          { (char *)"setSampleRate", _wrap_setSampleRate, METH_VARARGS, NULL },
3720          { (char *)"getFFTLength", _wrap_getFFTLength, METH_VARARGS, NULL },
3721          { (char *)"setFFTLength", _wrap_setFFTLength, METH_VARARGS, NULL },
3722          { (char *)"getTuneFFT", _wrap_getTuneFFT, METH_VARARGS, NULL },
3723          { (char *)"getTuneFracRel", _wrap_getTuneFracRel, METH_VARARGS, NULL },
3724          { (char *)"getVFOOffset", _wrap_getVFOOffset, METH_VARARGS, NULL },
3725          { (char *)"setVFOOffset", _wrap_setVFOOffset, METH_VARARGS, NULL },
3726          { (char *)"getIOUDClock", _wrap_getIOUDClock, METH_VARARGS, NULL },
3727          { (char *)"setIOUDClock", _wrap_setIOUDClock, METH_VARARGS, NULL },
3728          { (char *)"getDACMult", _wrap_getDACMult, METH_VARARGS, NULL },
3729          { (char *)"setDACMult", _wrap_setDACMult, METH_VARARGS, NULL },
3730          { (char *)"getAMP_Relay", _wrap_getAMP_Relay, METH_VARARGS, NULL },
3731          { (char *)"setAMP_Relay", _wrap_setAMP_Relay, METH_VARARGS, NULL },
3732          { (char *)"getATTN_Relay", _wrap_getATTN_Relay, METH_VARARGS, NULL },
3733          { (char *)"setATTN_Relay", _wrap_setATTN_Relay, METH_VARARGS, NULL },
3734          { (char *)"getXVTR_TR_Relay", _wrap_getXVTR_TR_Relay, METH_VARARGS, NULL },
3735          { (char *)"setXVTR_TR_Relay", _wrap_setXVTR_TR_Relay, METH_VARARGS, NULL },
3736          { (char *)"getXVTR_Relay", _wrap_getXVTR_Relay, METH_VARARGS, NULL },
3737          { (char *)"setXVTR_Relay", _wrap_setXVTR_Relay, METH_VARARGS, NULL },
3738          { (char *)"getIMPULSE_Relay", _wrap_getIMPULSE_Relay, METH_VARARGS, NULL },
3739          { (char *)"setIMPULSE_Relay", _wrap_setIMPULSE_Relay, METH_VARARGS, NULL },
3740          { (char *)"getPA_TransmitRelay", _wrap_getPA_TransmitRelay, METH_VARARGS, NULL },
3741          { (char *)"setPA_TransmitRelay", _wrap_setPA_TransmitRelay, METH_VARARGS, NULL },
3742          { (char *)"getPA_BiasOn", _wrap_getPA_BiasOn, METH_VARARGS, NULL },
3743          { (char *)"setPA_BiasOn", _wrap_setPA_BiasOn, METH_VARARGS, NULL },
3744          { NULL, NULL, 0, NULL }
3745 };
3746
3747
3748 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3749
3750 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}};
3751 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}};
3752 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}};
3753
3754 static swig_type_info *swig_types_initial[] = {
3755 _swigt__p_ushort, 
3756 _swigt__p_char, 
3757 _swigt__p_u_short, 
3758 0
3759 };
3760
3761
3762 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3763
3764 static swig_const_info swig_const_table[] = {
3765 {0, 0, 0, 0.0, 0, 0}};
3766
3767 #ifdef __cplusplus
3768 }
3769 #endif
3770
3771 #ifdef __cplusplus
3772 extern "C"
3773 #endif
3774 SWIGEXPORT(void) SWIG_init(void) {
3775     static PyObject *SWIG_globals = 0; 
3776     static int       typeinit = 0;
3777     PyObject *m, *d;
3778     int       i;
3779     if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
3780     m = Py_InitModule((char *) SWIG_name, SwigMethods);
3781     d = PyModule_GetDict(m);
3782     
3783     if (!typeinit) {
3784         for (i = 0; swig_types_initial[i]; i++) {
3785             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
3786         }
3787         typeinit = 1;
3788     }
3789     SWIG_InstallConstants(d,swig_const_table);
3790     
3791     PyDict_SetItemString(d,"FALSE", SWIG_From_int((int)0));
3792     PyDict_SetItemString(d,"TRUE", SWIG_From_int((int)1));
3793     PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
3794     SWIG_addvarlink(SWIG_globals,(char*)"DttSP_SampleRate",_wrap_DttSP_SampleRate_get, _wrap_DttSP_SampleRate_set);
3795     PyDict_SetItemString(d,"IARU1", SWIG_From_int((int)IARU1));
3796     PyDict_SetItemString(d,"IARU2", SWIG_From_int((int)IARU2));
3797     PyDict_SetItemString(d,"IARU3", SWIG_From_int((int)IARU3));
3798     PyDict_SetItemString(d,"BYPASS", SWIG_From_int((int)BYPASS));
3799     PyDict_SetItemString(d,"MEMORY", SWIG_From_int((int)MEMORY));
3800     PyDict_SetItemString(d,"FULL", SWIG_From_int((int)FULL));
3801     PyDict_SetItemString(d,"LAST", SWIG_From_int((int)LAST));
3802     PyDict_SetItemString(d,"POSITIVE", SWIG_From_int((int)POSITIVE));
3803     PyDict_SetItemString(d,"NEGATIVE", SWIG_From_int((int)NEGATIVE));
3804     PyDict_SetItemString(d,"NONE", SWIG_From_int((int)NONE));
3805     PyDict_SetItemString(d,"bsnone", SWIG_From_int((int)bsnone));
3806     PyDict_SetItemString(d,"bs0", SWIG_From_int((int)bs0));
3807     PyDict_SetItemString(d,"bs1", SWIG_From_int((int)bs1));
3808     PyDict_SetItemString(d,"bs2", SWIG_From_int((int)bs2));
3809     PyDict_SetItemString(d,"bs3", SWIG_From_int((int)bs3));
3810     PyDict_SetItemString(d,"bs4", SWIG_From_int((int)bs4));
3811     PyDict_SetItemString(d,"bs5", SWIG_From_int((int)bs5));
3812     PyDict_SetItemString(d,"EXT", SWIG_From_int((int)EXT));
3813     PyDict_SetItemString(d,"BPF", SWIG_From_int((int)BPF));
3814     PyDict_SetItemString(d,"DAT", SWIG_From_int((int)DAT));
3815     PyDict_SetItemString(d,"ADR", SWIG_From_int((int)ADR));
3816     PyDict_SetItemString(d,"PIN_12", SWIG_From_int((int)PIN_12));
3817     PyDict_SetItemString(d,"Dash", SWIG_From_int((int)Dash));
3818     PyDict_SetItemString(d,"Dot", SWIG_From_int((int)Dot));
3819     PyDict_SetItemString(d,"PA_DATA", SWIG_From_int((int)PA_DATA));
3820     PyDict_SetItemString(d,"PIN_11", SWIG_From_int((int)PIN_11));
3821     PyDict_SetItemString(d,"P1", SWIG_From_int((int)P1));
3822     PyDict_SetItemString(d,"P2", SWIG_From_int((int)P2));
3823     PyDict_SetItemString(d,"P3", SWIG_From_int((int)P3));
3824     PyDict_SetItemString(d,"P4", SWIG_From_int((int)P4));
3825     PyDict_SetItemString(d,"P5", SWIG_From_int((int)P5));
3826     PyDict_SetItemString(d,"P6", SWIG_From_int((int)P6));
3827     PyDict_SetItemString(d,"P7", SWIG_From_int((int)P7));
3828     PyDict_SetItemString(d,"SER", SWIG_From_int((int)0x01));
3829     PyDict_SetItemString(d,"SCK", SWIG_From_int((int)0x02));
3830     PyDict_SetItemString(d,"SCLR_NOT", SWIG_From_int((int)0x04));
3831     PyDict_SetItemString(d,"DCDR_NE", SWIG_From_int((int)0x20));
3832     PyDict_SetItemString(d,"IC11", SWIG_From_int((int)IC11));
3833     PyDict_SetItemString(d,"IC7", SWIG_From_int((int)IC7));
3834     PyDict_SetItemString(d,"IC9", SWIG_From_int((int)IC9));
3835     PyDict_SetItemString(d,"IC10", SWIG_From_int((int)IC10));
3836     PyDict_SetItemString(d,"LPF0", SWIG_From_int((int)0x01));
3837     PyDict_SetItemString(d,"LPF1", SWIG_From_int((int)0x02));
3838     PyDict_SetItemString(d,"LPF2", SWIG_From_int((int)0x04));
3839     PyDict_SetItemString(d,"LPF3", SWIG_From_int((int)0x08));
3840     PyDict_SetItemString(d,"LPF4", SWIG_From_int((int)0x10));
3841     PyDict_SetItemString(d,"LPF5", SWIG_From_int((int)0x20));
3842     PyDict_SetItemString(d,"LPF6", SWIG_From_int((int)0x40));
3843     PyDict_SetItemString(d,"LPF7", SWIG_From_int((int)0x80));
3844     PyDict_SetItemString(d,"LPF8", SWIG_From_int((int)0x01));
3845     PyDict_SetItemString(d,"LPF9", SWIG_From_int((int)0x02));
3846     PyDict_SetItemString(d,"BPF0", SWIG_From_int((int)0x80));
3847     PyDict_SetItemString(d,"BPF1", SWIG_From_int((int)0x40));
3848     PyDict_SetItemString(d,"BPF2", SWIG_From_int((int)0x10));
3849     PyDict_SetItemString(d,"BPF3", SWIG_From_int((int)0x20));
3850     PyDict_SetItemString(d,"BPF4", SWIG_From_int((int)0x08));
3851     PyDict_SetItemString(d,"BPF5", SWIG_From_int((int)0x04));
3852     SWIG_addvarlink(SWIG_globals,(char*)"ic11_memory",_wrap_ic11_memory_get, _wrap_ic11_memory_set);
3853     PyDict_SetItemString(d,"PAF0", SWIG_From_int((int)0x01));
3854     PyDict_SetItemString(d,"PAF1", SWIG_From_int((int)0x02));
3855     PyDict_SetItemString(d,"PAF2", SWIG_From_int((int)0x04));
3856     PyDict_SetItemString(d,"ADC_CLK", SWIG_From_int((int)0x08));
3857     PyDict_SetItemString(d,"ADC_DI", SWIG_From_int((int)0x10));
3858     PyDict_SetItemString(d,"ADC_CS_NOT", SWIG_From_int((int)0x20));
3859     PyDict_SetItemString(d,"PATR", SWIG_From_int((int)0x40));
3860     PyDict_SetItemString(d,"ATUCTL", SWIG_From_int((int)0x80));
3861     SWIG_addvarlink(SWIG_globals,(char*)"ic7_memory",_wrap_ic7_memory_get, _wrap_ic7_memory_set);
3862     PyDict_SetItemString(d,"AMP_RLYS", SWIG_From_int((int)0x03));
3863     PyDict_SetItemString(d,"XVTR_TR_RLY", SWIG_From_int((int)0x04));
3864     PyDict_SetItemString(d,"XVTR_RLY", SWIG_From_int((int)0x08));
3865     PyDict_SetItemString(d,"ATTN_RLY", SWIG_From_int((int)0x10));
3866     PyDict_SetItemString(d,"IMPULSE_RLY", SWIG_From_int((int)0x20));
3867     PyDict_SetItemString(d,"PA_BIAS_NOT", SWIG_From_int((int)0x40));
3868     PyDict_SetItemString(d,"IMPULSE", SWIG_From_int((int)0x80));
3869     SWIG_addvarlink(SWIG_globals,(char*)"rfe_enabled",_wrap_rfe_enabled_get, _wrap_rfe_enabled_set);
3870     SWIG_addvarlink(SWIG_globals,(char*)"xvtr_enabled",_wrap_xvtr_enabled_get, _wrap_xvtr_enabled_set);
3871     SWIG_addvarlink(SWIG_globals,(char*)"pa_enabled",_wrap_pa_enabled_get, _wrap_pa_enabled_set);
3872     PyDict_SetItemString(d,"PA_LPF_OFF", SWIG_From_int((int)0));
3873     PyDict_SetItemString(d,"PA_LPF_12_10", SWIG_From_int((int)0x01));
3874     PyDict_SetItemString(d,"PA_LPF_17_15", SWIG_From_int((int)0x02));
3875     PyDict_SetItemString(d,"PA_LPF_30_20", SWIG_From_int((int)0x01+0x02));
3876     PyDict_SetItemString(d,"PA_LPF_60_40", SWIG_From_int((int)0x04));
3877     PyDict_SetItemString(d,"PA_LPF_80", SWIG_From_int((int)0x04+0x01));
3878     PyDict_SetItemString(d,"PA_LPF_160", SWIG_From_int((int)0x04+0x02));
3879     PyDict_SetItemString(d,"PA_FORWARD_PWR", SWIG_From_int((int)0));
3880     PyDict_SetItemString(d,"PA_REVERSE_PWR", SWIG_From_int((int)1));
3881     PyDict_SetItemString(d,"TR", SWIG_From_int((int)0x40));
3882     PyDict_SetItemString(d,"MUTE", SWIG_From_int((int)0x80));
3883     PyDict_SetItemString(d,"GAIN", SWIG_From_int((int)0x80));
3884     PyDict_SetItemString(d,"WRB", SWIG_From_int((int)0x40));
3885     PyDict_SetItemString(d,"RESET", SWIG_From_int((int)0x80));
3886     SWIG_addvarlink(SWIG_globals,(char*)"band_relay",_wrap_band_relay_get, _wrap_band_relay_set);
3887     SWIG_addvarlink(SWIG_globals,(char*)"external_output",_wrap_external_output_get, _wrap_external_output_set);
3888     SWIG_addvarlink(SWIG_globals,(char*)"mute_relay",_wrap_mute_relay_get, _wrap_mute_relay_set);
3889     SWIG_addvarlink(SWIG_globals,(char*)"transmit_relay",_wrap_transmit_relay_get, _wrap_transmit_relay_set);
3890     SWIG_addvarlink(SWIG_globals,(char*)"gain_relay",_wrap_gain_relay_get, _wrap_gain_relay_set);
3891     SWIG_addvarlink(SWIG_globals,(char*)"latch_delay",_wrap_latch_delay_get, _wrap_latch_delay_set);
3892     PyDict_SetItemString(d,"COMP_PD", SWIG_From_int((int)0x10));
3893     PyDict_SetItemString(d,"DIG_PD", SWIG_From_int((int)0x01));
3894     PyDict_SetItemString(d,"BYPASS_PLL", SWIG_From_int((int)0x20));
3895     PyDict_SetItemString(d,"INT_IOUD", SWIG_From_int((int)0x01));
3896     PyDict_SetItemString(d,"OSK_EN", SWIG_From_int((int)0x20));
3897     PyDict_SetItemString(d,"OSK_INT", SWIG_From_int((int)0x10));
3898     PyDict_SetItemString(d,"BYPASS_SINC", SWIG_From_int((int)0x40));
3899     PyDict_SetItemString(d,"PLL_RANGE", SWIG_From_int((int)0x40));
3900     SWIG_addvarlink(SWIG_globals,(char*)"dds_clock",_wrap_dds_clock_get, _wrap_dds_clock_set);
3901     SWIG_addvarlink(SWIG_globals,(char*)"pll_mult",_wrap_pll_mult_get, _wrap_pll_mult_set);
3902     SWIG_addvarlink(SWIG_globals,(char*)"dds_clock_correction",_wrap_dds_clock_correction_get, _wrap_dds_clock_correction_set);
3903     SWIG_addvarlink(SWIG_globals,(char*)"sysClock",_wrap_sysClock_get, _wrap_sysClock_set);
3904     SWIG_addvarlink(SWIG_globals,(char*)"ioud_clock",_wrap_ioud_clock_get, _wrap_ioud_clock_set);
3905     SWIG_addvarlink(SWIG_globals,(char*)"dac_mult",_wrap_dac_mult_get, _wrap_dac_mult_set);
3906     SWIG_addvarlink(SWIG_globals,(char*)"dds_freq",_wrap_dds_freq_get, _wrap_dds_freq_set);
3907     SWIG_addvarlink(SWIG_globals,(char*)"if_freq",_wrap_if_freq_get, _wrap_if_freq_set);
3908     SWIG_addvarlink(SWIG_globals,(char*)"if_shift",_wrap_if_shift_get, _wrap_if_shift_set);
3909     SWIG_addvarlink(SWIG_globals,(char*)"spur_reduction",_wrap_spur_reduction_get, _wrap_spur_reduction_set);
3910     SWIG_addvarlink(SWIG_globals,(char*)"dds_step_size",_wrap_dds_step_size_get, _wrap_dds_step_size_set);
3911     SWIG_addvarlink(SWIG_globals,(char*)"sample_rate",_wrap_sample_rate_get, _wrap_sample_rate_set);
3912     SWIG_addvarlink(SWIG_globals,(char*)"fft_length",_wrap_fft_length_get, _wrap_fft_length_set);
3913     SWIG_addvarlink(SWIG_globals,(char*)"FFT_Bin_Size",_wrap_FFT_Bin_Size_get, _wrap_FFT_Bin_Size_set);
3914     SWIG_addvarlink(SWIG_globals,(char*)"tune_fft",_wrap_tune_fft_get, _wrap_tune_fft_set);
3915     SWIG_addvarlink(SWIG_globals,(char*)"tune_frac_rel",_wrap_tune_frac_rel_get, _wrap_tune_frac_rel_set);
3916     SWIG_addvarlink(SWIG_globals,(char*)"vfo_offset",_wrap_vfo_offset_get, _wrap_vfo_offset_set);
3917     SWIG_addvarlink(SWIG_globals,(char*)"min_freq",_wrap_min_freq_get, _wrap_min_freq_set);
3918     SWIG_addvarlink(SWIG_globals,(char*)"max_freq",_wrap_max_freq_get, _wrap_max_freq_set);
3919     SWIG_addvarlink(SWIG_globals,(char*)"baseAdr",_wrap_baseAdr_get, _wrap_baseAdr_set);
3920     SWIG_addvarlink(SWIG_globals,(char*)"curBandPlan",_wrap_curBandPlan_get, _wrap_curBandPlan_set);
3921     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);
3922     SWIG_addvarlink(SWIG_globals,(char*)"last_tuning_word",_wrap_last_tuning_word_get, _wrap_last_tuning_word_set);
3923     SWIG_addvarlink(SWIG_globals,(char*)"usb_enabled",_wrap_usb_enabled_get, _wrap_usb_enabled_set);
3924     PyDict_SetItemString(d,"SDR1K_LATCH_EXT", SWIG_From_int((int)0x01));
3925     PyDict_SetItemString(d,"SDR1K_LATCH_BPF", SWIG_From_int((int)0x02));
3926 }
3927