Main Page   Data Structures   File List   Data Fields   Globals   Related Pages   Examples  

rig.h

Go to the documentation of this file.
00001 /*
00002  *  Hamlib Interface - API header
00003  *  Copyright (c) 2000-2003 by Stephane Fillod and Frank Singleton
00004  *
00005  *      $Id: rig.h,v 1.80 2003/04/27 22:15:04 fillods Exp $
00006  *
00007  *   This library is free software; you can redistribute it and/or modify
00008  *   it under the terms of the GNU Library General Public License as
00009  *   published by the Free Software Foundation; either version 2 of
00010  *   the License, or (at your option) any later version.
00011  *
00012  *   This program is distributed in the hope that it will be useful,
00013  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015  *   GNU Library General Public License for more details.
00016  *
00017  *   You should have received a copy of the GNU Library General Public
00018  *   License along with this library; if not, write to the Free Software
00019  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00020  *
00021  */
00022 
00023 #ifndef _RIG_H
00024 #define _RIG_H 1
00025 
00026 #include <hamlib/riglist.h>     /* list in another file to not mess up w/ this one */
00027 #include <stdio.h>              /* required for FILE definition */
00028 #include <sys/time.h>           /* required for struct timeval */
00029 
00030 #if defined(__CYGWIN__) || defined(_WIN32)
00031 #include <windows.h>            /* HANDLE definition */
00032 #else
00033 #include <sys/socket.h>         /* required for struct sockaddr */
00034 #endif
00035 
00045 /* __BEGIN_DECLS should be used at the beginning of your declarations,
00046  * so that C++ compilers don't mangle their names.  Use __END_DECLS at
00047  * the end of C declarations. */
00048 #undef __BEGIN_DECLS
00049 #undef __END_DECLS
00050 #ifdef __cplusplus
00051 # define __BEGIN_DECLS extern "C" {
00052 # define __END_DECLS }
00053 #else
00054 # define __BEGIN_DECLS          /* empty */
00055 # define __END_DECLS            /* empty */
00056 #endif
00057 
00058 /* HAMLIB_PARAMS is a macro used to wrap function prototypes, so that compilers
00059  * that don't understand ANSI C prototypes still work, and ANSI C
00060  * compilers can issue warnings about type mismatches. */
00061 #undef HAMLIB_PARAMS
00062 #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(__CYGWIN__) || defined(_WIN32) || defined(__cplusplus)
00063 # define HAMLIB_PARAMS(protos) protos
00064 # define rig_ptr_t     void*
00065 #else
00066 # define HAMLIB_PARAMS(protos) ()
00067 # define rig_ptr_t     char*
00068 #endif
00069 
00070 #include <hamlib/rig_dll.h>
00071 
00072 
00073 __BEGIN_DECLS
00074 
00075 extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
00076 extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[];
00077 
00082 enum rig_errcode_e {
00083         RIG_OK=0,               /*<! No error, operation completed sucessfully */
00084         RIG_EINVAL,             /*<! invalid parameter */
00085         RIG_ECONF,              /*<! invalid configuration (serial,..) */
00086         RIG_ENOMEM,             /*<! memory shortage */
00087         RIG_ENIMPL,             /*<! function not implemented, but will be */
00088         RIG_ETIMEOUT,           /*<! communication timed out */
00089         RIG_EIO,                /*<! IO error, including open failed */
00090         RIG_EINTERNAL,          /*<! Internal Hamlib error, huh! */
00091         RIG_EPROTO,             /*<! Protocol error */
00092         RIG_ERJCTED,            /*<! Command rejected by the rig */
00093         RIG_ETRUNC,             /*<! Command performed, but arg truncated */
00094         RIG_ENAVAIL,            /*<! function not available */
00095         RIG_ENTARGET,           /*<! VFO not targetable */
00096         RIG_BUSERROR,           /*<! Error talking on the bus */
00097         RIG_BUSBUSY,            /*<! Collision on the bus */
00098 };
00099 
00107 enum rig_debug_level_e {
00108   RIG_DEBUG_NONE = 0,           /*<! no bug reporting */
00109   RIG_DEBUG_BUG,                /*<! serious bug */
00110   RIG_DEBUG_ERR,                /*<! error case (e.g. protocol, memory allocation) */
00111   RIG_DEBUG_WARN,               /*<! warning */
00112   RIG_DEBUG_VERBOSE,            /*<! verbose */
00113   RIG_DEBUG_TRACE               /*<! tracing */
00114 };
00115 
00116 /* --------------- Rig capabilities -----------------*/
00117 
00118 /* Forward struct references */
00119 
00120 struct rig;
00121 struct rig_state;
00122 
00126 typedef struct rig RIG;
00127 
00128 #define RIGNAMSIZ 30
00129 #define RIGVERSIZ 8
00130 #define FILPATHLEN 100
00131 #define FRQRANGESIZ 30
00132 #define MAXCHANDESC 30          /* describe channel eg: "WWV 5Mhz" */
00133 #define TSLSTSIZ 20             /* max tuning step list size, zero ended */
00134 #define FLTLSTSIZ 16            /* max mode/filter list size, zero ended */
00135 #define MAXDBLSTSIZ 8           /* max preamp/att levels supported, zero ended */
00136 #define CHANLSTSIZ 16           /* max mem_list size, zero ended */
00137 
00138 
00149 typedef unsigned int tone_t;
00150 
00154 typedef enum rig_port_e {
00155   RIG_PORT_NONE = 0,            
00156   RIG_PORT_SERIAL,              
00157   RIG_PORT_NETWORK,             
00158   RIG_PORT_DEVICE,              
00159   RIG_PORT_PACKET,              
00160   RIG_PORT_DTMF,                
00161   RIG_PORT_ULTRA,               
00162   RIG_PORT_RPC,                 
00163   RIG_PORT_PARALLEL,            
00164 } rig_port_t;
00165 
00169 enum serial_parity_e {
00170   RIG_PARITY_NONE = 0,          
00171   RIG_PARITY_ODD,               
00172   RIG_PARITY_EVEN               
00173 };
00174 
00178 enum serial_handshake_e {
00179   RIG_HANDSHAKE_NONE = 0,       
00180   RIG_HANDSHAKE_XONXOFF,        
00181   RIG_HANDSHAKE_HARDWARE        
00182 };
00183 
00184 
00188 enum serial_control_state_e {
00189   RIG_SIGNAL_UNSET = 0, 
00190   RIG_SIGNAL_ON,        
00191   RIG_SIGNAL_OFF        
00192 };
00193 
00195 typedef enum {
00196         RIG_FLAG_RECEIVER =     (1<<1),         
00197         RIG_FLAG_TRANSMITTER =  (1<<2),         
00198         RIG_FLAG_SCANNER =      (1<<3),         
00200         RIG_FLAG_MOBILE =       (1<<4),         
00201         RIG_FLAG_HANDHELD =     (1<<5),         
00202         RIG_FLAG_COMPUTER =     (1<<6),         
00203         RIG_FLAG_TRUNKING =     (1<<7),         
00204         RIG_FLAG_APRS =         (1<<8),         
00205         RIG_FLAG_TNC =          (1<<9),         
00206         RIG_FLAG_DXCLUSTER =    (1<<10),        
00207         RIG_FLAG_TUNER =        (1<<11),        
00208 } rig_type_t;
00209 
00210 #define RIG_FLAG_TRANSCEIVER (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER)
00211 #define RIG_TYPE_MASK (RIG_FLAG_TRANSCEIVER|RIG_FLAG_SCANNER|RIG_FLAG_MOBILE|RIG_FLAG_HANDHELD|RIG_FLAG_COMPUTER|RIG_FLAG_TRUNKING|RIG_FLAG_TUNER)
00212 
00213 #define RIG_TYPE_OTHER          0
00214 #define RIG_TYPE_TRANSCEIVER    RIG_FLAG_TRANSCEIVER
00215 #define RIG_TYPE_HANDHELD       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD)
00216 #define RIG_TYPE_MOBILE         (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE)
00217 #define RIG_TYPE_RECEIVER       RIG_FLAG_RECEIVER
00218 #define RIG_TYPE_PCRECEIVER     (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER)
00219 #define RIG_TYPE_SCANNER        (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER)
00220 #define RIG_TYPE_TRUNKSCANNER   (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING)
00221 #define RIG_TYPE_COMPUTER       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER)
00222 #define RIG_TYPE_TUNER          RIG_FLAG_TUNER
00223 
00224 
00228 enum rig_status_e {
00229   RIG_STATUS_ALPHA = 0,         
00230   RIG_STATUS_UNTESTED,          
00231   RIG_STATUS_BETA,              
00232   RIG_STATUS_STABLE,            
00233   RIG_STATUS_BUGGY,             
00234   RIG_STATUS_NEW                
00235 };
00236 
00240 typedef enum {
00241   RIG_RPT_SHIFT_NONE = 0,       
00242   RIG_RPT_SHIFT_MINUS,          
00243   RIG_RPT_SHIFT_PLUS            
00244 } rptr_shift_t;
00245 
00249 typedef enum {
00250   RIG_SPLIT_OFF = 0,            
00251   RIG_SPLIT_ON,                 
00252 } split_t;
00253 
00260 typedef signed long long freq_t;
00261 
00266 typedef signed long shortfreq_t;
00267 
00268 #define Hz(f)   ((freq_t)(f))
00269 #define kHz(f)  ((freq_t)((f)*(freq_t)1000))
00270 #define MHz(f)  ((freq_t)((f)*(freq_t)1000000))
00271 #define GHz(f)  ((freq_t)((f)*(freq_t)1000000000))
00272 
00273 #define RIG_FREQ_NONE Hz(0)
00274 
00275 
00290 typedef int vfo_t;
00291 
00293 #define RIG_VFO_NONE    0
00294 
00295 #define RIG_VFO_TX_FLAG    ((vfo_t)(1<<30))
00296 
00298 #define RIG_VFO_CURR    ((vfo_t)(1<<29))
00299 
00301 #define RIG_VFO_MEM     ((vfo_t)(1<<28))
00302 
00304 #define RIG_VFO_VFO     ((vfo_t)(1<<27))
00305 
00306 #define RIG_VFO_TX_VFO(v)       ((v)|RIG_VFO_TX_FLAG)
00307 
00309 #define RIG_VFO_TX      RIG_VFO_TX_VFO(RIG_VFO_CURR)
00310 
00312 #define RIG_VFO_RX      RIG_VFO_CURR
00313 
00315 #define RIG_VFO_MAIN    ((vfo_t)(1<<26))
00316 
00317 #define RIG_VFO_SUB     ((vfo_t)(1<<25))
00318 
00319 #define RIG_VFO_N(n) ((vfo_t)(1<<(n)))
00320 
00322 #define RIG_VFO_A RIG_VFO_N(0)
00323 
00324 #define RIG_VFO_B RIG_VFO_N(1)
00325 
00326 #define RIG_VFO_C RIG_VFO_N(2)
00327 
00328 
00329 #define RIG_TARGETABLE_NONE 0x00
00330 #define RIG_TARGETABLE_FREQ 0x01
00331 #define RIG_TARGETABLE_MODE 0x02
00332 #define RIG_TARGETABLE_ALL  0xffffffffU
00333 
00334 
00335 #define RIG_PASSBAND_NORMAL Hz(0)
00336 
00340 typedef shortfreq_t pbwidth_t;
00341 
00342 
00346 typedef enum dcd_e {
00347   RIG_DCD_OFF = 0,              
00348   RIG_DCD_ON                    
00349 } dcd_t;
00350 
00355 typedef enum {
00356   RIG_DCD_NONE = 0,             
00357   RIG_DCD_RIG,                  
00358   RIG_DCD_SERIAL_DSR,           
00359   RIG_DCD_SERIAL_CTS,           
00360   RIG_DCD_PARALLEL,             
00361 } dcd_type_t;
00362 
00363 
00367 typedef enum {
00368   RIG_PTT_OFF = 0,              
00369   RIG_PTT_ON                    
00370 } ptt_t;
00371 
00376 typedef enum {
00377   RIG_PTT_NONE = 0,             
00378   RIG_PTT_RIG,                  
00379   RIG_PTT_SERIAL_DTR,           
00380   RIG_PTT_SERIAL_RTS,           
00381   RIG_PTT_PARALLEL              
00382 } ptt_type_t;
00383 
00387 typedef enum {
00388   RIG_POWER_OFF =       0,              
00389   RIG_POWER_ON =        (1<<0),         
00390   RIG_POWER_STANDBY =   (1<<1),         
00391 } powerstat_t;
00392 
00396 typedef enum {
00397   RIG_RESET_NONE =       0,             
00398   RIG_RESET_SOFT =      (1<<0),         
00399   RIG_RESET_VFO =       (1<<1),         
00400   RIG_RESET_MCALL =     (1<<2),         
00401   RIG_RESET_MASTER =    (1<<3),         
00402 } reset_t;
00403 
00404 
00416 typedef enum {
00417         RIG_OP_NONE =           0,
00418         RIG_OP_CPY =            (1<<0), 
00419         RIG_OP_XCHG =           (1<<1), 
00420         RIG_OP_FROM_VFO =       (1<<2), 
00421         RIG_OP_TO_VFO =         (1<<3), 
00422         RIG_OP_MCL =            (1<<4), 
00423         RIG_OP_UP =             (1<<5), 
00424         RIG_OP_DOWN =           (1<<6), 
00425         RIG_OP_BAND_UP =        (1<<7), 
00426         RIG_OP_BAND_DOWN =      (1<<8), 
00427         RIG_OP_LEFT =           (1<<9), 
00428         RIG_OP_RIGHT =          (1<<10),
00429         RIG_OP_TUNE =           (1<<11),
00430 } vfo_op_t;
00431 
00432 
00436 typedef enum {
00437         RIG_SCAN_NONE =         0,
00438         RIG_SCAN_STOP =         RIG_SCAN_NONE, 
00439         RIG_SCAN_MEM =          (1<<0), 
00440         RIG_SCAN_SLCT =         (1<<1), 
00441         RIG_SCAN_PRIO =         (1<<2), 
00442         RIG_SCAN_PROG =         (1<<3), 
00443         RIG_SCAN_DELTA =        (1<<4), 
00444         RIG_SCAN_VFO =          (1<<5), 
00445 } scan_t;
00446 
00450 typedef long token_t;
00451 
00452 #define RIG_CONF_END 0
00453 
00454 /*
00455  * strongly inspired from soundmedem. Thanks Thomas!
00456  */
00457 enum rig_conf_e {
00458         RIG_CONF_STRING,        
00459         RIG_CONF_COMBO,         
00460         RIG_CONF_NUMERIC,       
00461         RIG_CONF_CHECKBUTTON,   
00462 };
00463 
00464 #define RIG_COMBO_MAX   8
00465 
00469 struct confparams {
00470   token_t token;                
00471   const char *name;             
00472   const char *label;            
00473   const char *tooltip;          
00474   const char *dflt;             
00475   enum rig_conf_e type;         
00476   union {                       
00477         struct {                
00478                 float min;      
00479                 float max;      
00480                 float step;     
00481         } n;                    
00482         struct {                
00483                 const char *combostr[RIG_COMBO_MAX];    
00484         } c;                    
00485   } u;                          
00486 };
00487 
00491 typedef enum {
00492         RIG_ANN_NONE =  0,              
00493         RIG_ANN_OFF =   RIG_ANN_NONE,   
00494         RIG_ANN_FREQ =  (1<<0),         
00495         RIG_ANN_RXMODE = (1<<1),        
00496         RIG_ANN_CW = (1<<2),            
00497         RIG_ANN_ENG = (1<<3),           
00498         RIG_ANN_JAP = (1<<4),           
00499 } ann_t;
00500 
00501 
00502 /* Antenna number */
00503 typedef int ant_t;
00504 
00505 #define RIG_ANT_NONE    0
00506 #define RIG_ANT_N(n)    ((ant_t)1<<(n))
00507 #define RIG_ANT_1       RIG_ANT_N(0)
00508 #define RIG_ANT_2       RIG_ANT_N(1)
00509 #define RIG_ANT_3       RIG_ANT_N(2)
00510 
00511 
00512 /* TODO: kill me, and replace by real AGC delay */
00513 enum agc_level_e {
00514         RIG_AGC_OFF = 0,
00515         RIG_AGC_SUPERFAST,
00516         RIG_AGC_FAST,
00517         RIG_AGC_SLOW,
00518         RIG_AGC_USER,           
00519 };
00520 
00524 enum meter_level_e {
00525   RIG_METER_NONE =      0,              /*< No display meter */
00526   RIG_METER_SWR =       (1<<0),         /*< Stationary Wave Ratio */
00527   RIG_METER_COMP =      (1<<1),         /*< Compression level */
00528   RIG_METER_ALC =       (1<<2),         /*< ALC */
00529   RIG_METER_IC =        (1<<3),         /*< IC */
00530   RIG_METER_DB =        (1<<4),         /*< DB */
00531 };
00532 
00537 typedef union {
00538   signed int i;                 
00539   float f;                      
00540   char *s;                      
00541   const char *cs;               
00542 } value_t;
00543 
00545 enum rig_level_e {
00546         RIG_LEVEL_NONE =        0,      
00547         RIG_LEVEL_PREAMP =      (1<<0), 
00548         RIG_LEVEL_ATT =         (1<<1), 
00549         RIG_LEVEL_VOX =         (1<<2), 
00550         RIG_LEVEL_AF =          (1<<3), 
00551         RIG_LEVEL_RF =          (1<<4), 
00552         RIG_LEVEL_SQL =         (1<<5), 
00553         RIG_LEVEL_IF =          (1<<6), 
00554         RIG_LEVEL_APF =         (1<<7), 
00555         RIG_LEVEL_NR =          (1<<8), 
00556         RIG_LEVEL_PBT_IN =      (1<<9), 
00557         RIG_LEVEL_PBT_OUT =     (1<<10),
00558         RIG_LEVEL_CWPITCH =     (1<<11),
00559         RIG_LEVEL_RFPOWER =     (1<<12),
00560         RIG_LEVEL_MICGAIN =     (1<<13),
00561         RIG_LEVEL_KEYSPD =      (1<<14),
00562         RIG_LEVEL_NOTCHF =      (1<<15),
00563         RIG_LEVEL_COMP =        (1<<16),
00564         RIG_LEVEL_AGC =         (1<<17),
00565         RIG_LEVEL_BKINDL =      (1<<18),
00566         RIG_LEVEL_BALANCE =     (1<<19),
00567         RIG_LEVEL_METER =       (1<<20),
00569         RIG_LEVEL_VOXGAIN =     (1<<21),
00570         RIG_LEVEL_VOXDELAY =  RIG_LEVEL_VOX,    
00571         RIG_LEVEL_ANTIVOX =     (1<<22),
00574         RIG_LEVEL_SQLSTAT =     (1<<27),
00575         RIG_LEVEL_SWR =         (1<<28),
00576         RIG_LEVEL_ALC =         (1<<29),
00577         RIG_LEVEL_STRENGTH =    (1<<30),
00578 };
00579 
00580 #define RIG_LEVEL_FLOAT_LIST (RIG_LEVEL_AF|RIG_LEVEL_RF|RIG_LEVEL_SQL|RIG_LEVEL_APF|RIG_LEVEL_NR|RIG_LEVEL_PBT_IN|RIG_LEVEL_PBT_OUT|RIG_LEVEL_RFPOWER|RIG_LEVEL_MICGAIN|RIG_LEVEL_COMP|RIG_LEVEL_BALANCE|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_VOXGAIN|RIG_LEVEL_ANTIVOX)
00581 
00582 #define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH)
00583 
00584 #define RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST)
00585 #define RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST)
00586 
00587 
00592 enum rig_parm_e {
00593         RIG_PARM_NONE =         0,      
00594         RIG_PARM_ANN =          (1<<0), 
00595         RIG_PARM_APO =          (1<<1), 
00596         RIG_PARM_BACKLIGHT =    (1<<2), 
00597         RIG_PARM_BEEP =         (1<<4), 
00598         RIG_PARM_TIME =         (1<<5), 
00599         RIG_PARM_BAT =          (1<<6), 
00600         RIG_PARM_KEYLIGHT =     (1<<7), 
00601 };
00602 
00603 #define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
00604 #define RIG_PARM_READONLY_LIST (RIG_PARM_BAT)
00605 
00606 #define RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST)
00607 #define RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST)
00608 
00609 #define RIG_SETTING_MAX 64
00610 
00616 typedef unsigned long long setting_t;
00617 
00618 /*
00619  * tranceive mode, ie. the rig notify the host of any event,
00620  * like freq changed, mode changed, etc.
00621  */
00622 #define RIG_TRN_OFF 0
00623 #define RIG_TRN_RIG 1
00624 #define RIG_TRN_POLL 2
00625 
00626 
00630 enum rig_func_e {
00631         RIG_FUNC_NONE =         0,      
00632         RIG_FUNC_FAGC =         (1<<0), 
00633         RIG_FUNC_NB =           (1<<1), 
00634         RIG_FUNC_COMP =         (1<<2), 
00635         RIG_FUNC_VOX =          (1<<3), 
00636         RIG_FUNC_TONE =         (1<<4), 
00637         RIG_FUNC_TSQL =         (1<<5), 
00638         RIG_FUNC_SBKIN =        (1<<6), 
00639         RIG_FUNC_FBKIN =        (1<<7), 
00640         RIG_FUNC_ANF =          (1<<8), 
00641         RIG_FUNC_NR =           (1<<9), 
00642         RIG_FUNC_AIP =          (1<<10),
00643         RIG_FUNC_APF =          (1<<11),
00644         RIG_FUNC_MON =          (1<<12),
00645         RIG_FUNC_MN =           (1<<13),
00646         RIG_FUNC_RNF =          (1<<14),
00647         RIG_FUNC_ARO =          (1<<15),
00648         RIG_FUNC_LOCK =         (1<<16),
00649         RIG_FUNC_MUTE =         (1<<17),
00650         RIG_FUNC_VSC =          (1<<18),
00651         RIG_FUNC_REV =          (1<<19),
00652         RIG_FUNC_SQL =          (1<<20),
00653         RIG_FUNC_ABM =          (1<<21),
00654         RIG_FUNC_BC =           (1<<22),
00655         RIG_FUNC_MBC =          (1<<23),
00656         /*                      (1<<24), used to be RIG_FUNC_LMP, see RIG_PARM_BACKLIGHT instead) */
00657         RIG_FUNC_AFC =          (1<<25),
00658         RIG_FUNC_SATMODE =      (1<<26),
00659         RIG_FUNC_SCOPE =        (1<<27),
00660         RIG_FUNC_RESUME =       (1<<28),
00661         RIG_FUNC_TBURST =       (1<<29),
00662         RIG_FUNC_TUNER =        (1<<30),
00663 };
00664 
00665 /*
00666  * power unit macros, converts to mW
00667  * This is limited to 2MW on 32 bits systems.
00668  */
00669 #define mW(p)    ((int)(p))
00670 #define Watts(p) ((int)((p)*1000))
00671 #define W(p)     Watts(p)
00672 #define kW(p)    ((int)((p)*1000000L))
00673 
00677 typedef enum {
00678         RIG_MODE_NONE =         0,      
00679         RIG_MODE_AM =           (1<<0), 
00680         RIG_MODE_CW =           (1<<1), 
00681         RIG_MODE_USB =          (1<<2), 
00682         RIG_MODE_LSB =          (1<<3), 
00683         RIG_MODE_RTTY =         (1<<4), 
00684         RIG_MODE_FM =           (1<<5), 
00685         RIG_MODE_WFM =          (1<<6), 
00686         RIG_MODE_CWR =          (1<<7), 
00687         RIG_MODE_RTTYR =        (1<<8), 
00688 } rmode_t;
00689 
00691 #define RIG_MODE_SSB    (RIG_MODE_USB|RIG_MODE_LSB)
00692 
00693 
00694 #define RIG_DBLST_END 0         /* end marker in a preamp/att level list */
00695 #define RIG_IS_DBLST_END(d) ((d)==0)
00696 
00703 typedef struct freq_range_list {
00704   freq_t start;         
00705   freq_t end;           
00706   rmode_t modes;        
00707   int low_power;        
00708   int high_power;       
00709   vfo_t vfo;            
00710   ant_t ant;            
00711 } freq_range_t;
00712 
00713 #define RIG_FRNG_END     {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE}
00714 #define RIG_IS_FRNG_END(r) ((r).start == Hz(0) && (r).end == Hz(0))
00715 
00716 #define RIG_ITU_REGION1 1
00717 #define RIG_ITU_REGION2 2
00718 #define RIG_ITU_REGION3 3
00719 
00739 struct tuning_step_list {
00740   rmode_t modes;        
00741   shortfreq_t ts;       
00742 };
00743 
00744 #define RIG_TS_ANY     0
00745 #define RIG_TS_END     {RIG_MODE_NONE,0}
00746 #define RIG_IS_TS_END(t)        ((t).modes == RIG_MODE_NONE && (t).ts == 0)
00747 
00774 struct filter_list {
00775   rmode_t modes;        
00776   pbwidth_t width;      
00777 };
00778 
00779 #define RIG_FLT_ANY     0
00780 #define RIG_FLT_END     {RIG_MODE_NONE,0}
00781 #define RIG_IS_FLT_END(f)       ((f).modes == RIG_MODE_NONE)
00782 
00783 
00784 /*
00785  * Used in the channel.flags field
00786  */
00787 #define RIG_CHFLAG_NONE 0
00788 #define RIG_CHFLAG_SKIP (1<<0)
00789 
00794 struct ext_list {
00795   token_t token;        
00796   value_t val;          
00797 };
00798 
00799 #define RIG_EXT_END     {0, {.i=0}}
00800 #define RIG_IS_EXT_END(x)       ((x).token == 0)
00801 
00809 struct channel {
00810   int channel_num;              
00811   int bank_num;                 
00812   vfo_t vfo;                    
00813   int ant;                      
00814   freq_t freq;                  
00815   rmode_t mode;                 
00816   pbwidth_t width;              
00818   freq_t tx_freq;               
00819   rmode_t tx_mode;              
00820   pbwidth_t tx_width;           
00822   split_t split;                
00823   vfo_t tx_vfo;                 
00825   rptr_shift_t rptr_shift;      
00826   shortfreq_t rptr_offs;        
00827   shortfreq_t tuning_step;      
00828   shortfreq_t rit;              
00829   shortfreq_t xit;              
00830   setting_t funcs;              
00831   value_t levels[RIG_SETTING_MAX];      
00832   tone_t ctcss_tone;            
00833   tone_t ctcss_sql;             
00834   tone_t dcs_code;              
00835   tone_t dcs_sql;               
00836   int scan_group;               
00837   int flags;                    
00838   char channel_desc[MAXCHANDESC];       
00839   struct ext_list *ext_levels;  
00840 };
00842 typedef struct channel channel_t;
00843 
00849 struct channel_cap {
00850   unsigned bank_num:1;          
00851   unsigned vfo:1;               
00852   unsigned ant:1;               
00853   unsigned freq:1;              
00854   unsigned mode:1;              
00855   unsigned width:1;             
00857   unsigned tx_freq:1;           
00858   unsigned tx_mode:1;           
00859   unsigned tx_width:1;          
00861   unsigned split:1;             
00862   unsigned tx_vfo:1;            
00863   unsigned rptr_shift:1;        
00864   unsigned rptr_offs:1;         
00865   unsigned tuning_step:1;       
00866   unsigned rit:1;               
00867   unsigned xit:1;               
00868   setting_t funcs;              
00869   setting_t levels;             
00870   unsigned ctcss_tone:1;        
00871   unsigned ctcss_sql:1;         
00872   unsigned dcs_code:1;          
00873   unsigned dcs_sql:1;           
00874   unsigned scan_group:1;        
00875   unsigned flags:1;             
00876   unsigned channel_desc:1;      
00877   unsigned ext_levels:1;        
00878 };
00879 
00881 typedef struct channel_cap channel_cap_t;
00882 
00883 
00894 typedef enum {
00895   RIG_MTYPE_NONE=0,             
00896   RIG_MTYPE_MEM,                
00897   RIG_MTYPE_EDGE,               
00898   RIG_MTYPE_CALL,               
00899   RIG_MTYPE_MEMOPAD,            
00900   RIG_MTYPE_SAT                 
00901 } chan_type_t;
00902 
00916 struct chan_list {
00917   int start;                    
00918   int end;                      
00919   chan_type_t type;             
00920   channel_cap_t mem_caps;       
00921 };
00922 
00923 #define RIG_CHAN_END     {0,0,RIG_MTYPE_NONE}
00924 #define RIG_IS_CHAN_END(c)      ((c).type == RIG_MTYPE_NONE)
00925 
00927 typedef struct chan_list chan_t;
00928 
00930 typedef float gran_t;
00931 
00932 
00951 struct rig_caps {
00952   rig_model_t rig_model;        
00953   const char *model_name;       
00954   const char *mfg_name;         
00955   const char *version;          
00956   const char *copyright;        
00957   enum rig_status_e status;     
00959   int rig_type;                 
00960   ptt_type_t ptt_type;          
00961   dcd_type_t dcd_type;          
00962   rig_port_t port_type;         
00964   int serial_rate_min;          
00965   int serial_rate_max;          
00966   int serial_data_bits;         
00967   int serial_stop_bits;         
00968   enum serial_parity_e serial_parity;           
00969   enum serial_handshake_e serial_handshake;     
00971   int write_delay;              
00972   int post_write_delay;         
00973   int timeout;                  
00974   int retry;                    
00976   setting_t has_get_func;       
00977   setting_t has_set_func;       
00978   setting_t has_get_level;      
00979   setting_t has_set_level;      
00980   setting_t has_get_parm;       
00981   setting_t has_set_parm;       
00983   gran_t level_gran[RIG_SETTING_MAX];   
00984   gran_t parm_gran[RIG_SETTING_MAX];    
00986   const struct confparams *extparms;    
00987   const struct confparams *extlevels;   
00989   const tone_t *ctcss_list;     
00990   const tone_t *dcs_list;       
00992   int preamp[MAXDBLSTSIZ];      
00993   int attenuator[MAXDBLSTSIZ];  
00994   shortfreq_t max_rit;          
00995   shortfreq_t max_xit;          
00996   shortfreq_t max_ifshift;      
00998   ann_t announces;      
01000   vfo_op_t vfo_ops;     
01001   scan_t scan_ops;      
01002   int targetable_vfo;   
01003   int transceive;       
01005   int bank_qty;         
01006   int chan_desc_sz;     
01008   chan_t chan_list[CHANLSTSIZ]; 
01010   freq_range_t rx_range_list1[FRQRANGESIZ];     
01011   freq_range_t tx_range_list1[FRQRANGESIZ];     
01012   freq_range_t rx_range_list2[FRQRANGESIZ];     
01013   freq_range_t tx_range_list2[FRQRANGESIZ];     
01015   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01016   struct filter_list filters[FLTLSTSIZ];                
01018   const struct confparams *cfgparams;            
01019   const rig_ptr_t priv;                          
01021         /*
01022          * Rig API
01023          *
01024          */
01025 
01026   int (*rig_init) (RIG * rig);
01027   int (*rig_cleanup) (RIG * rig);
01028   int (*rig_open) (RIG * rig);
01029   int (*rig_close) (RIG * rig);
01030 
01031         /*
01032          *  General API commands, from most primitive to least.. :()
01033          *  List Set/Get functions pairs
01034          */
01035 
01036   int (*set_freq) (RIG * rig, vfo_t vfo, freq_t freq);
01037   int (*get_freq) (RIG * rig, vfo_t vfo, freq_t * freq);
01038 
01039   int (*set_mode) (RIG * rig, vfo_t vfo, rmode_t mode,
01040                          pbwidth_t width);
01041   int (*get_mode) (RIG * rig, vfo_t vfo, rmode_t * mode,
01042                          pbwidth_t * width);
01043 
01044   int (*set_vfo) (RIG * rig, vfo_t vfo);
01045   int (*get_vfo) (RIG * rig, vfo_t * vfo);
01046 
01047   int (*set_ptt) (RIG * rig, vfo_t vfo, ptt_t ptt);
01048   int (*get_ptt) (RIG * rig, vfo_t vfo, ptt_t * ptt);
01049   int (*get_dcd) (RIG * rig, vfo_t vfo, dcd_t * dcd);
01050 
01051   int (*set_rptr_shift) (RIG * rig, vfo_t vfo,
01052                                rptr_shift_t rptr_shift);
01053   int (*get_rptr_shift) (RIG * rig, vfo_t vfo,
01054                                rptr_shift_t * rptr_shift);
01055 
01056   int (*set_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t offs);
01057   int (*get_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t * offs);
01058 
01059   int (*set_split_freq) (RIG * rig, vfo_t vfo, freq_t tx_freq);
01060   int (*get_split_freq) (RIG * rig, vfo_t vfo, freq_t * tx_freq);
01061   int (*set_split_mode) (RIG * rig, vfo_t vfo, rmode_t tx_mode,
01062                                pbwidth_t tx_width);
01063   int (*get_split_mode) (RIG * rig, vfo_t vfo, rmode_t * tx_mode,
01064                                pbwidth_t * tx_width);
01065 
01066   int (*set_split_vfo) (RIG * rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
01067   int (*get_split_vfo) (RIG * rig, vfo_t vfo, split_t * split, vfo_t *tx_vfo);
01068 
01069   int (*set_rit) (RIG * rig, vfo_t vfo, shortfreq_t rit);
01070   int (*get_rit) (RIG * rig, vfo_t vfo, shortfreq_t * rit);
01071   int (*set_xit) (RIG * rig, vfo_t vfo, shortfreq_t xit);
01072   int (*get_xit) (RIG * rig, vfo_t vfo, shortfreq_t * xit);
01073 
01074   int (*set_ts) (RIG * rig, vfo_t vfo, shortfreq_t ts);
01075   int (*get_ts) (RIG * rig, vfo_t vfo, shortfreq_t * ts);
01076 
01077   int (*set_dcs_code) (RIG * rig, vfo_t vfo, tone_t code);
01078   int (*get_dcs_code) (RIG * rig, vfo_t vfo, tone_t * code);
01079   int (*set_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01080   int (*get_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01081   int (*set_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01082   int (*get_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01083 
01084   int (*set_dcs_sql) (RIG * rig, vfo_t vfo, tone_t code);
01085   int (*get_dcs_sql) (RIG * rig, vfo_t vfo, tone_t * code);
01086   int (*set_tone_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01087   int (*get_tone_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01088   int (*set_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01089   int (*get_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01090 
01091   int (*power2mW) (RIG * rig, unsigned int *mwpower, float power,
01092                          freq_t freq, rmode_t mode);
01093   int (*mW2power) (RIG * rig, float *power, unsigned int mwpower,
01094                          freq_t freq, rmode_t mode);
01095 
01096   int (*set_powerstat) (RIG * rig, powerstat_t status);
01097   int (*get_powerstat) (RIG * rig, powerstat_t * status);
01098   int (*reset) (RIG * rig, reset_t reset);
01099 
01100   int (*set_ant) (RIG * rig, vfo_t vfo, ant_t ant);
01101   int (*get_ant) (RIG * rig, vfo_t vfo, ant_t * ant);
01102 
01103   int (*set_level) (RIG * rig, vfo_t vfo, setting_t level,
01104                           value_t val);
01105   int (*get_level) (RIG * rig, vfo_t vfo, setting_t level,
01106                           value_t * val);
01107 
01108   int (*set_func) (RIG * rig, vfo_t vfo, setting_t func, int status);
01109   int (*get_func) (RIG * rig, vfo_t vfo, setting_t func,
01110                          int *status);
01111 
01112   int (*set_parm) (RIG * rig, setting_t parm, value_t val);
01113   int (*get_parm) (RIG * rig, setting_t parm, value_t * val);
01114 
01115   int (*set_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t val);
01116   int (*get_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t *val);
01117 
01118   int (*set_ext_parm)(RIG *rig, token_t token, value_t val);
01119   int (*get_ext_parm)(RIG *rig, token_t token, value_t *val);
01120 
01121   int (*set_conf) (RIG * rig, token_t token, const char *val);
01122   int (*get_conf) (RIG * rig, token_t token, char *val);
01123 
01124   int (*send_dtmf) (RIG * rig, vfo_t vfo, const char *digits);
01125   int (*recv_dtmf) (RIG * rig, vfo_t vfo, char *digits, int *length);
01126   int (*send_morse) (RIG * rig, vfo_t vfo, const char *msg);
01127 
01128   int (*set_bank) (RIG * rig, vfo_t vfo, int bank);
01129   int (*set_mem) (RIG * rig, vfo_t vfo, int ch);
01130   int (*get_mem) (RIG * rig, vfo_t vfo, int *ch);
01131   int (*vfo_op) (RIG * rig, vfo_t vfo, vfo_op_t op);
01132   int (*scan) (RIG * rig, vfo_t vfo, scan_t scan, int ch);
01133 
01134   int (*set_trn) (RIG * rig, int trn);
01135   int (*get_trn) (RIG * rig, int *trn);
01136 
01137   int (*decode_event) (RIG * rig);
01138 
01139   int (*set_channel) (RIG * rig, const channel_t * chan);
01140   int (*get_channel) (RIG * rig, channel_t * chan);
01141 
01142   const char *(*get_info) (RIG * rig);
01143 
01144 };
01145 
01151 typedef struct {
01152   union {
01153         rig_port_t rig;         
01154         ptt_type_t ptt;         
01155         dcd_type_t dcd;         
01156   } type;
01157   int fd;                       
01158   FILE *stream;                 
01159 #if defined(__CYGWIN__) || defined(_WIN32)
01160   HANDLE handle;                
01161 #endif
01162 
01163   int write_delay;              
01164   int post_write_delay;         
01165   struct timeval post_write_date;       
01166   int timeout;                  
01167   int retry;                    
01169   char pathname[FILPATHLEN];    
01170   union {
01171         struct {
01172                 int rate;       
01173                 int data_bits;  
01174                 int stop_bits;  
01175                 enum serial_parity_e parity;            
01176                 enum serial_handshake_e handshake;      
01177                 enum serial_control_state_e rts_state;  
01178                 enum serial_control_state_e dtr_state;  
01179         } serial;               
01180         struct {
01181                 int pin;        
01182         } parallel;             
01183         struct {
01184 #if defined(__CYGWIN__) || defined(_WIN32)
01185 #else
01186                 struct sockaddr saddr;  
01187 #endif
01188         } network;              
01189   } parm;                       
01190 } port_t;
01191 
01192 
01202 struct rig_state {
01203         /*
01204          * overridable fields
01205          */
01206   port_t rigport;       
01207   port_t pttport;       
01208   port_t dcdport;       
01210   double vfo_comp;      
01212   int itu_region;       
01213   freq_range_t rx_range_list[FRQRANGESIZ];      
01214   freq_range_t tx_range_list[FRQRANGESIZ];      
01216   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01218   struct filter_list filters[FLTLSTSIZ];        
01220   chan_t chan_list[CHANLSTSIZ]; 
01222   shortfreq_t max_rit;          
01223   shortfreq_t max_xit;          
01224   shortfreq_t max_ifshift;      
01226   ann_t announces;              
01228   int preamp[MAXDBLSTSIZ];      
01229   int attenuator[MAXDBLSTSIZ];  
01231   setting_t has_get_func;       
01232   setting_t has_set_func;       
01233   setting_t has_get_level;      
01234   setting_t has_set_level;      
01235   setting_t has_get_parm;       
01236   setting_t has_set_parm;       
01238   gran_t level_gran[RIG_SETTING_MAX];   
01239   gran_t parm_gran[RIG_SETTING_MAX];    
01242         /* 
01243          * non overridable fields, internal use
01244          */
01245 
01246   int hold_decode;      
01247   vfo_t current_vfo;    
01248   int transceive;       
01249   int vfo_list;         
01250   int comm_state;       
01251   rig_ptr_t priv;       
01252   rig_ptr_t obj;        
01254 };
01255 
01256 
01257 typedef int (*freq_cb_t) (RIG *, vfo_t, freq_t, rig_ptr_t);
01258 typedef int (*mode_cb_t) (RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t);
01259 typedef int (*vfo_cb_t) (RIG *, vfo_t, rig_ptr_t);
01260 typedef int (*ptt_cb_t) (RIG *, vfo_t, ptt_t, rig_ptr_t);
01261 typedef int (*dcd_cb_t) (RIG *, vfo_t, dcd_t, rig_ptr_t);
01262 
01280 struct rig_callbacks {
01281   freq_cb_t freq_event; 
01282   rig_ptr_t freq_arg;   
01283   mode_cb_t mode_event; 
01284   rig_ptr_t mode_arg;   
01285   vfo_cb_t vfo_event;   
01286   rig_ptr_t vfo_arg;    
01287   ptt_cb_t ptt_event;   
01288   rig_ptr_t ptt_arg;    
01289   dcd_cb_t dcd_event;   
01290   rig_ptr_t dcd_arg;    
01291   /* etc.. */
01292 };
01293 
01303 struct rig {
01304   struct rig_caps *caps;                
01305   struct rig_state state;               
01306   struct rig_callbacks callbacks;       
01307 };
01308 
01309 
01310 
01311 /* --------------- API function prototypes -----------------*/
01312 
01313 extern HAMLIB_EXPORT(RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model));
01314 extern HAMLIB_EXPORT(int) rig_open HAMLIB_PARAMS((RIG *rig));
01315 
01316   /*
01317    *  General API commands, from most primitive to least.. :()
01318    *  List Set/Get functions pairs
01319    */
01320 
01321 extern HAMLIB_EXPORT(int) rig_set_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t freq));
01322 extern HAMLIB_EXPORT(int) rig_get_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *freq));
01323 
01324 extern HAMLIB_EXPORT(int) rig_set_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width));
01325 extern HAMLIB_EXPORT(int) rig_get_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width));
01326 
01327 extern HAMLIB_EXPORT(int) rig_set_vfo HAMLIB_PARAMS((RIG *rig, vfo_t vfo));
01328 extern HAMLIB_EXPORT(int) rig_get_vfo HAMLIB_PARAMS((RIG *rig, vfo_t *vfo));
01329 
01330 extern HAMLIB_EXPORT(int) rig_set_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t ptt));
01331 extern HAMLIB_EXPORT(int) rig_get_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t *ptt));
01332 
01333 extern HAMLIB_EXPORT(int) rig_get_dcd HAMLIB_PARAMS((RIG *rig, vfo_t vfo, dcd_t *dcd));
01334 
01335 extern HAMLIB_EXPORT(int) rig_set_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift));
01336 extern HAMLIB_EXPORT(int) rig_get_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift));
01337 extern HAMLIB_EXPORT(int) rig_set_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rptr_offs));
01338 extern HAMLIB_EXPORT(int) rig_get_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs));
01339 
01340 extern HAMLIB_EXPORT(int) rig_set_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01341 extern HAMLIB_EXPORT(int) rig_get_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01342 extern HAMLIB_EXPORT(int) rig_set_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01343 extern HAMLIB_EXPORT(int) rig_get_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01344 
01345 extern HAMLIB_EXPORT(int) rig_set_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01346 extern HAMLIB_EXPORT(int) rig_get_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01347 extern HAMLIB_EXPORT(int) rig_set_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01348 extern HAMLIB_EXPORT(int) rig_get_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01349 
01350 extern HAMLIB_EXPORT(int) rig_set_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t tx_freq));
01351 extern HAMLIB_EXPORT(int) rig_get_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *tx_freq));
01352 extern HAMLIB_EXPORT(int) rig_set_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width));
01353 extern HAMLIB_EXPORT(int) rig_get_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width));
01354 extern HAMLIB_EXPORT(int) rig_set_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t split, vfo_t tx_vfo));
01355 extern HAMLIB_EXPORT(int) rig_get_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t *split, vfo_t *tx_vfo));
01356 #define rig_set_split(r,v,s) rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR)
01357 #define rig_get_split(r,v,s) ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); })
01358 
01359 extern HAMLIB_EXPORT(int) rig_set_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rit));
01360 extern HAMLIB_EXPORT(int) rig_get_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rit));
01361 extern HAMLIB_EXPORT(int) rig_set_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t xit));
01362 extern HAMLIB_EXPORT(int) rig_get_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *xit));
01363 
01364 extern HAMLIB_EXPORT(int) rig_set_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t ts));
01365 extern HAMLIB_EXPORT(int) rig_get_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *ts));
01366 
01367 extern HAMLIB_EXPORT(int) rig_power2mW HAMLIB_PARAMS((RIG *rig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode));
01368 extern HAMLIB_EXPORT(int) rig_mW2power HAMLIB_PARAMS((RIG *rig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode));
01369 
01370 extern HAMLIB_EXPORT(shortfreq_t) rig_get_resolution HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01371 
01372 extern HAMLIB_EXPORT(int) rig_set_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t val));
01373 extern HAMLIB_EXPORT(int) rig_get_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t *val));
01374 
01375 #define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s))
01376 
01377 extern HAMLIB_EXPORT(int) rig_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t val));
01378 extern HAMLIB_EXPORT(int) rig_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t *val));
01379 
01380 extern HAMLIB_EXPORT(int) rig_set_conf HAMLIB_PARAMS((RIG *rig, token_t token, const char *val));
01381 extern HAMLIB_EXPORT(int) rig_get_conf HAMLIB_PARAMS((RIG *rig, token_t token, char *val));
01382 
01383 extern HAMLIB_EXPORT(int) rig_set_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t status));
01384 extern HAMLIB_EXPORT(int) rig_get_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t *status));
01385 
01386 extern HAMLIB_EXPORT(int) rig_reset HAMLIB_PARAMS((RIG *rig, reset_t reset));   /* dangerous! */
01387 
01388 extern HAMLIB_EXPORT(int) rig_set_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01389                         token_t token, value_t val));
01390 extern HAMLIB_EXPORT(int) rig_get_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01391                         token_t token, value_t *val));
01392 
01393 extern HAMLIB_EXPORT(int) rig_set_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t val));
01394 extern HAMLIB_EXPORT(int) rig_get_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t *val));
01395 
01396 extern HAMLIB_EXPORT(int) rig_ext_level_foreach HAMLIB_PARAMS((RIG *rig, int (*cfunc)(RIG*, const struct confparams *, rig_ptr_t), rig_ptr_t data));
01397 extern HAMLIB_EXPORT(int) rig_ext_parm_foreach HAMLIB_PARAMS((RIG *rig, int (*cfunc)(RIG*, const struct confparams *, rig_ptr_t), rig_ptr_t data));
01398 extern HAMLIB_EXPORT(const struct confparams*) rig_ext_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01399 extern HAMLIB_EXPORT(token_t) rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01400 
01401 
01402 extern HAMLIB_EXPORT(int) rig_token_foreach HAMLIB_PARAMS((RIG *rig, int (*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data));
01403 extern HAMLIB_EXPORT(const struct confparams*) rig_confparam_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01404 extern HAMLIB_EXPORT(token_t) rig_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01405 
01406 extern HAMLIB_EXPORT(int) rig_close HAMLIB_PARAMS((RIG *rig));
01407 extern HAMLIB_EXPORT(int) rig_cleanup HAMLIB_PARAMS((RIG *rig));
01408 
01409 extern HAMLIB_EXPORT(int) rig_set_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t ant));  /* antenna */
01410 extern HAMLIB_EXPORT(int) rig_get_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t *ant));
01411 
01412 extern HAMLIB_EXPORT(setting_t) rig_has_get_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01413 extern HAMLIB_EXPORT(setting_t) rig_has_set_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01414 
01415 extern HAMLIB_EXPORT(setting_t) rig_has_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01416 extern HAMLIB_EXPORT(setting_t) rig_has_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01417 
01418 extern HAMLIB_EXPORT(setting_t) rig_has_get_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01419 extern HAMLIB_EXPORT(setting_t) rig_has_set_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01420 
01421 extern HAMLIB_EXPORT(int) rig_set_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int status));
01422 extern HAMLIB_EXPORT(int) rig_get_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int *status));
01423 
01424 extern HAMLIB_EXPORT(int) rig_send_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *digits));
01425 extern HAMLIB_EXPORT(int) rig_recv_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, char *digits, int *length));
01426 extern HAMLIB_EXPORT(int) rig_send_morse HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *msg));
01427 
01428 extern HAMLIB_EXPORT(int) rig_set_bank HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int bank));
01429 extern HAMLIB_EXPORT(int) rig_set_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int ch));
01430 extern HAMLIB_EXPORT(int) rig_get_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int *ch));
01431 extern HAMLIB_EXPORT(int) rig_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_t vfo, vfo_op_t op));
01432 extern HAMLIB_EXPORT(vfo_op_t) rig_has_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_op_t op));
01433 extern HAMLIB_EXPORT(int) rig_scan HAMLIB_PARAMS((RIG *rig, vfo_t vfo, scan_t scan, int ch));
01434 extern HAMLIB_EXPORT(scan_t) rig_has_scan HAMLIB_PARAMS((RIG *rig, scan_t scan));
01435 
01436 extern HAMLIB_EXPORT(int) rig_set_channel HAMLIB_PARAMS((RIG *rig, const channel_t *chan));     /* mem */
01437 extern HAMLIB_EXPORT(int) rig_get_channel HAMLIB_PARAMS((RIG *rig, channel_t *chan));
01438 
01439 extern HAMLIB_EXPORT(int) rig_set_trn HAMLIB_PARAMS((RIG *rig, int trn));
01440 extern HAMLIB_EXPORT(int) rig_get_trn HAMLIB_PARAMS((RIG *rig, int *trn));
01441 extern HAMLIB_EXPORT(int) rig_set_freq_callback HAMLIB_PARAMS((RIG *, freq_cb_t, rig_ptr_t));
01442 extern HAMLIB_EXPORT(int) rig_set_mode_callback HAMLIB_PARAMS((RIG *, mode_cb_t, rig_ptr_t));
01443 extern HAMLIB_EXPORT(int) rig_set_vfo_callback HAMLIB_PARAMS((RIG *, vfo_cb_t, rig_ptr_t));
01444 extern HAMLIB_EXPORT(int) rig_set_ptt_callback HAMLIB_PARAMS((RIG *, ptt_cb_t, rig_ptr_t));
01445 extern HAMLIB_EXPORT(int) rig_set_dcd_callback HAMLIB_PARAMS((RIG *, dcd_cb_t, rig_ptr_t));
01446 
01447 extern HAMLIB_EXPORT(const char *) rig_get_info HAMLIB_PARAMS((RIG *rig));
01448 
01449 extern HAMLIB_EXPORT(const struct rig_caps *) rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model));
01450 extern HAMLIB_EXPORT(const freq_range_t *) rig_get_range HAMLIB_PARAMS((const freq_range_t range_list[], freq_t freq, rmode_t mode));
01451 
01452 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_normal HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01453 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_narrow HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01454 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_wide HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01455 
01456 extern HAMLIB_EXPORT(const char *) rigerror HAMLIB_PARAMS((int errnum));
01457 
01458 extern HAMLIB_EXPORT(int) rig_setting2idx HAMLIB_PARAMS((setting_t s));
01459 #define rig_idx2setting(i) (1ULL<<(i))
01460 
01461 /*
01462  * Even if these functions are prefixed with "rig_", they are not rig specific
01463  * Maybe "hamlib_" would have been better. Let me know. --SF
01464  */
01465 extern HAMLIB_EXPORT(void) rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01466 extern HAMLIB_EXPORT(int) rig_need_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01467 extern HAMLIB_EXPORT(void) rig_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level, const char *fmt, ...));
01468 
01469 extern HAMLIB_EXPORT(int) rig_register HAMLIB_PARAMS((const struct rig_caps *caps));
01470 extern HAMLIB_EXPORT(int) rig_unregister HAMLIB_PARAMS((rig_model_t rig_model));
01471 extern HAMLIB_EXPORT(int) rig_list_foreach HAMLIB_PARAMS((int (*cfunc)(const struct rig_caps*, rig_ptr_t), rig_ptr_t data));
01472 extern HAMLIB_EXPORT(int) rig_load_backend HAMLIB_PARAMS((const char *be_name));
01473 extern HAMLIB_EXPORT(int) rig_check_backend HAMLIB_PARAMS((rig_model_t rig_model));
01474 extern HAMLIB_EXPORT(int) rig_load_all_backends HAMLIB_PARAMS(());
01475 
01476 typedef int (*rig_probe_func_t)(const port_t *, rig_model_t, rig_ptr_t);
01477 extern HAMLIB_EXPORT(int) rig_probe_all HAMLIB_PARAMS((port_t *p, rig_probe_func_t, rig_ptr_t));
01478 extern HAMLIB_EXPORT(rig_model_t) rig_probe HAMLIB_PARAMS((port_t *p));
01479 
01480 
01481 __END_DECLS
01482 
01483 #endif /* _RIG_H */

Generated on Mon May 26 17:46:56 2003 for Hamlib - the C library reference by doxygen1.3-rc3