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