rig.h

Go to the documentation of this file.
00001 /*
00002  *  Hamlib Interface - API header
00003  *  Copyright (c) 2000-2005 by Stephane Fillod and Frank Singleton
00004  *
00005  *      $Id: rig.h,v 1.106 2005/04/03 22:33:08 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 
00037 /* __BEGIN_DECLS should be used at the beginning of your declarations,
00038  * so that C++ compilers don't mangle their names.  Use __END_DECLS at
00039  * the end of C declarations. */
00040 #undef __BEGIN_DECLS
00041 #undef __END_DECLS
00042 #ifdef __cplusplus
00043 # define __BEGIN_DECLS extern "C" {
00044 # define __END_DECLS }
00045 #else
00046 # define __BEGIN_DECLS          /* empty */
00047 # define __END_DECLS            /* empty */
00048 #endif
00049 
00050 /* HAMLIB_PARAMS is a macro used to wrap function prototypes, so that compilers
00051  * that don't understand ANSI C prototypes still work, and ANSI C
00052  * compilers can issue warnings about type mismatches. */
00053 #undef HAMLIB_PARAMS
00054 #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(__CYGWIN__) || defined(_WIN32) || defined(__cplusplus)
00055 # define HAMLIB_PARAMS(protos) protos
00056 # define rig_ptr_t     void*
00057 #else
00058 # define HAMLIB_PARAMS(protos) ()
00059 # define rig_ptr_t     char*
00060 #endif
00061 
00062 #include <hamlib/rig_dll.h>
00063 
00064 
00065 __BEGIN_DECLS
00066 
00067 extern HAMLIB_EXPORT_VAR(const char) hamlib_version[];
00068 extern HAMLIB_EXPORT_VAR(const char) hamlib_copyright[];
00069 
00074 enum rig_errcode_e {
00075         RIG_OK=0,               /*<! No error, operation completed sucessfully */
00076         RIG_EINVAL,             /*<! invalid parameter */
00077         RIG_ECONF,              /*<! invalid configuration (serial,..) */
00078         RIG_ENOMEM,             /*<! memory shortage */
00079         RIG_ENIMPL,             /*<! function not implemented, but will be */
00080         RIG_ETIMEOUT,           /*<! communication timed out */
00081         RIG_EIO,                /*<! IO error, including open failed */
00082         RIG_EINTERNAL,          /*<! Internal Hamlib error, huh! */
00083         RIG_EPROTO,             /*<! Protocol error */
00084         RIG_ERJCTED,            /*<! Command rejected by the rig */
00085         RIG_ETRUNC,             /*<! Command performed, but arg truncated */
00086         RIG_ENAVAIL,            /*<! function not available */
00087         RIG_ENTARGET,           /*<! VFO not targetable */
00088         RIG_BUSERROR,           /*<! Error talking on the bus */
00089         RIG_BUSBUSY,            /*<! Collision on the bus */
00090         RIG_EARG,               /*<! NULL RIG handle or any invalid pointer parameter in get arg */
00091         RIG_EVFO,               /*<! Invalid VFO */
00092         RIG_EDOM                /*<! Argument out of domain of func */
00093 };
00094 
00102 enum rig_debug_level_e {
00103   RIG_DEBUG_NONE = 0,           /*<! no bug reporting */
00104   RIG_DEBUG_BUG,                /*<! serious bug */
00105   RIG_DEBUG_ERR,                /*<! error case (e.g. protocol, memory allocation) */
00106   RIG_DEBUG_WARN,               /*<! warning */
00107   RIG_DEBUG_VERBOSE,            /*<! verbose */
00108   RIG_DEBUG_TRACE               /*<! tracing */
00109 };
00110 
00111 /* --------------- Rig capabilities -----------------*/
00112 
00113 /* Forward struct references */
00114 
00115 struct rig;
00116 struct rig_state;
00117 
00121 typedef struct rig RIG;
00122 
00123 #define RIGNAMSIZ 30
00124 #define RIGVERSIZ 8
00125 #define FILPATHLEN 100
00126 #define FRQRANGESIZ 30
00127 #define MAXCHANDESC 30          /* describe channel eg: "WWV 5Mhz" */
00128 #define TSLSTSIZ 20             /* max tuning step list size, zero ended */
00129 #define FLTLSTSIZ 42            /* max mode/filter list size, zero ended */
00130 #define MAXDBLSTSIZ 8           /* max preamp/att levels supported, zero ended */
00131 #define CHANLSTSIZ 16           /* max mem_list size, zero ended */
00132 #define MAX_CAL_LENGTH 32       /* max calibration plots in cal_table_t */
00133 
00134 
00145 typedef unsigned int tone_t;
00146 
00150 typedef enum rig_port_e {
00151   RIG_PORT_NONE = 0,            
00152   RIG_PORT_SERIAL,              
00153   RIG_PORT_NETWORK,             
00154   RIG_PORT_DEVICE,              
00155   RIG_PORT_PACKET,              
00156   RIG_PORT_DTMF,                
00157   RIG_PORT_ULTRA,               
00158   RIG_PORT_RPC,                 
00159   RIG_PORT_PARALLEL             
00160 } rig_port_t;
00161 
00165 enum serial_parity_e {
00166   RIG_PARITY_NONE = 0,          
00167   RIG_PARITY_ODD,               
00168   RIG_PARITY_EVEN               
00169 };
00170 
00174 enum serial_handshake_e {
00175   RIG_HANDSHAKE_NONE = 0,       
00176   RIG_HANDSHAKE_XONXOFF,        
00177   RIG_HANDSHAKE_HARDWARE        
00178 };
00179 
00180 
00184 enum serial_control_state_e {
00185   RIG_SIGNAL_UNSET = 0, 
00186   RIG_SIGNAL_ON,        
00187   RIG_SIGNAL_OFF        
00188 };
00189 
00191 typedef enum {
00192         RIG_FLAG_RECEIVER =     (1<<1),         
00193         RIG_FLAG_TRANSMITTER =  (1<<2),         
00194         RIG_FLAG_SCANNER =      (1<<3),         
00196         RIG_FLAG_MOBILE =       (1<<4),         
00197         RIG_FLAG_HANDHELD =     (1<<5),         
00198         RIG_FLAG_COMPUTER =     (1<<6),         
00199         RIG_FLAG_TRUNKING =     (1<<7),         
00200         RIG_FLAG_APRS =         (1<<8),         
00201         RIG_FLAG_TNC =          (1<<9),         
00202         RIG_FLAG_DXCLUSTER =    (1<<10),        
00203         RIG_FLAG_TUNER =        (1<<11)         
00204 } rig_type_t;
00205 
00206 #define RIG_FLAG_TRANSCEIVER (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER)
00207 #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)
00208 
00209 #define RIG_TYPE_OTHER          0
00210 #define RIG_TYPE_TRANSCEIVER    RIG_FLAG_TRANSCEIVER
00211 #define RIG_TYPE_HANDHELD       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD)
00212 #define RIG_TYPE_MOBILE         (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE)
00213 #define RIG_TYPE_RECEIVER       RIG_FLAG_RECEIVER
00214 #define RIG_TYPE_PCRECEIVER     (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER)
00215 #define RIG_TYPE_SCANNER        (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER)
00216 #define RIG_TYPE_TRUNKSCANNER   (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING)
00217 #define RIG_TYPE_COMPUTER       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER)
00218 #define RIG_TYPE_TUNER          RIG_FLAG_TUNER
00219 
00220 
00224 enum rig_status_e {
00225   RIG_STATUS_ALPHA = 0,         
00226   RIG_STATUS_UNTESTED,          
00227   RIG_STATUS_BETA,              
00228   RIG_STATUS_STABLE,            
00229   RIG_STATUS_BUGGY,             
00230   RIG_STATUS_NEW                
00231 };
00232 
00236 typedef enum {
00237   RIG_RPT_SHIFT_NONE = 0,       
00238   RIG_RPT_SHIFT_MINUS,          
00239   RIG_RPT_SHIFT_PLUS            
00240 } rptr_shift_t;
00241 
00245 typedef enum {
00246   RIG_SPLIT_OFF = 0,            
00247   RIG_SPLIT_ON                  
00248 } split_t;
00249 
00254 typedef double freq_t;
00256 #define PRIfreq "f"
00257 
00258 #define SCNfreq "lf"
00259 #define FREQFMT SCNfreq
00260 
00265 typedef signed long shortfreq_t;
00266 
00267 #define Hz(f)   ((freq_t)(f))
00268 #define kHz(f)  ((freq_t)((f)*(freq_t)1000))
00269 #define MHz(f)  ((freq_t)((f)*(freq_t)1000000))
00270 #define GHz(f)  ((freq_t)((f)*(freq_t)1000000000))
00271 
00272 #define s_Hz(f)         ((shortfreq_t)(f))
00273 #define s_kHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000))
00274 #define s_MHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000000))
00275 #define s_GHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000000000))
00276 
00277 #define RIG_FREQ_NONE Hz(0)
00278 
00279 
00294 typedef int vfo_t;
00295 
00297 #define RIG_VFO_NONE    0
00298 
00299 #define RIG_VFO_TX_FLAG    ((vfo_t)(1<<30))
00300 
00302 #define RIG_VFO_CURR    ((vfo_t)(1<<29))
00303 
00305 #define RIG_VFO_MEM     ((vfo_t)(1<<28))
00306 
00308 #define RIG_VFO_VFO     ((vfo_t)(1<<27))
00309 
00310 #define RIG_VFO_TX_VFO(v)       ((v)|RIG_VFO_TX_FLAG)
00311 
00313 #define RIG_VFO_TX      RIG_VFO_TX_VFO(RIG_VFO_CURR)
00314 
00316 #define RIG_VFO_RX      RIG_VFO_CURR
00317 
00319 #define RIG_VFO_MAIN    ((vfo_t)(1<<26))
00320 
00321 #define RIG_VFO_SUB     ((vfo_t)(1<<25))
00322 
00323 #define RIG_VFO_N(n) ((vfo_t)(1<<(n)))
00324 
00326 #define RIG_VFO_A RIG_VFO_N(0)
00327 
00328 #define RIG_VFO_B RIG_VFO_N(1)
00329 
00330 #define RIG_VFO_C RIG_VFO_N(2)
00331 
00332 
00333 /*
00334  * targetable bitfields, for internal use.
00335  * RIG_TARGETABLE_PURE means a pure targetable radio on every command
00336  */
00337 #define RIG_TARGETABLE_NONE 0
00338 #define RIG_TARGETABLE_FREQ (1<<0)
00339 #define RIG_TARGETABLE_MODE (1<<1)
00340 #define RIG_TARGETABLE_PURE (1<<2)
00341 #define RIG_TARGETABLE_ALL  0x7fffffff
00342 
00343 
00344 #define RIG_PASSBAND_NORMAL s_Hz(0)
00345 
00349 typedef shortfreq_t pbwidth_t;
00350 
00351 
00355 typedef enum dcd_e {
00356   RIG_DCD_OFF = 0,              
00357   RIG_DCD_ON                    
00358 } dcd_t;
00359 
00364 typedef enum {
00365   RIG_DCD_NONE = 0,             
00366   RIG_DCD_RIG,                  
00367   RIG_DCD_SERIAL_DSR,           
00368   RIG_DCD_SERIAL_CTS,           
00369   RIG_DCD_SERIAL_CAR,           
00370   RIG_DCD_PARALLEL              
00371 } dcd_type_t;
00372 
00373 
00377 typedef enum {
00378   RIG_PTT_OFF = 0,              
00379   RIG_PTT_ON                    
00380 } ptt_t;
00381 
00386 typedef enum {
00387   RIG_PTT_NONE = 0,             
00388   RIG_PTT_RIG,                  
00389   RIG_PTT_SERIAL_DTR,           
00390   RIG_PTT_SERIAL_RTS,           
00391   RIG_PTT_PARALLEL              
00392 } ptt_type_t;
00393 
00397 typedef enum {
00398   RIG_POWER_OFF =       0,              
00399   RIG_POWER_ON =        (1<<0),         
00400   RIG_POWER_STANDBY =   (1<<1)          
00401 } powerstat_t;
00402 
00406 typedef enum {
00407   RIG_RESET_NONE =       0,             
00408   RIG_RESET_SOFT =      (1<<0),         
00409   RIG_RESET_VFO =       (1<<1),         
00410   RIG_RESET_MCALL =     (1<<2),         
00411   RIG_RESET_MASTER =    (1<<3)          
00412 } reset_t;
00413 
00414 
00426 typedef enum {
00427         RIG_OP_NONE =           0,
00428         RIG_OP_CPY =            (1<<0), 
00429         RIG_OP_XCHG =           (1<<1), 
00430         RIG_OP_FROM_VFO =       (1<<2), 
00431         RIG_OP_TO_VFO =         (1<<3), 
00432         RIG_OP_MCL =            (1<<4), 
00433         RIG_OP_UP =             (1<<5), 
00434         RIG_OP_DOWN =           (1<<6), 
00435         RIG_OP_BAND_UP =        (1<<7), 
00436         RIG_OP_BAND_DOWN =      (1<<8), 
00437         RIG_OP_LEFT =           (1<<9), 
00438         RIG_OP_RIGHT =          (1<<10),
00439         RIG_OP_TUNE =           (1<<11),
00440         RIG_OP_TOGGLE =         (1<<12) 
00441 } vfo_op_t;
00442 
00443 
00447 typedef enum {
00448         RIG_SCAN_NONE =         0,
00449         RIG_SCAN_STOP =         RIG_SCAN_NONE, 
00450         RIG_SCAN_MEM =          (1<<0), 
00451         RIG_SCAN_SLCT =         (1<<1), 
00452         RIG_SCAN_PRIO =         (1<<2), 
00453         RIG_SCAN_PROG =         (1<<3), 
00454         RIG_SCAN_DELTA =        (1<<4), 
00455         RIG_SCAN_VFO =          (1<<5), 
00456         RIG_SCAN_PLT =          (1<<6)  
00457 } scan_t;
00458 
00462 typedef long token_t;
00463 
00464 #define RIG_CONF_END 0
00465 
00466 /*
00467  * strongly inspired from soundmedem. Thanks Thomas!
00468  */
00469 enum rig_conf_e {
00470         RIG_CONF_STRING,        
00471         RIG_CONF_COMBO,         
00472         RIG_CONF_NUMERIC,       
00473         RIG_CONF_CHECKBUTTON    
00474 };
00475 
00476 #define RIG_COMBO_MAX   8
00477 
00481 struct confparams {
00482   token_t token;                
00483   const char *name;             
00484   const char *label;            
00485   const char *tooltip;          
00486   const char *dflt;             
00487   enum rig_conf_e type;         
00488   union {                       
00489         struct {                
00490                 float min;      
00491                 float max;      
00492                 float step;     
00493         } n;                    
00494         struct {                
00495                 const char *combostr[RIG_COMBO_MAX];    
00496         } c;                    
00497   } u;                          
00498 };
00499 
00503 typedef enum {
00504         RIG_ANN_NONE =  0,              
00505         RIG_ANN_OFF =   RIG_ANN_NONE,   
00506         RIG_ANN_FREQ =  (1<<0),         
00507         RIG_ANN_RXMODE = (1<<1),        
00508         RIG_ANN_CW = (1<<2),            
00509         RIG_ANN_ENG = (1<<3),           
00510         RIG_ANN_JAP = (1<<4)            
00511 } ann_t;
00512 
00513 
00514 /* Antenna number */
00515 typedef int ant_t;
00516 
00517 #define RIG_ANT_NONE    0
00518 #define RIG_ANT_N(n)    ((ant_t)1<<(n))
00519 #define RIG_ANT_1       RIG_ANT_N(0)
00520 #define RIG_ANT_2       RIG_ANT_N(1)
00521 #define RIG_ANT_3       RIG_ANT_N(2)
00522 #define RIG_ANT_4       RIG_ANT_N(3)
00523 
00524 
00525 /* TODO: kill me, and replace by real AGC delay */
00526 enum agc_level_e {
00527         RIG_AGC_OFF = 0,
00528         RIG_AGC_SUPERFAST,
00529         RIG_AGC_FAST,
00530         RIG_AGC_SLOW,
00531         RIG_AGC_USER,           
00532         RIG_AGC_MEDIUM
00533 };
00534 
00538 enum meter_level_e {
00539   RIG_METER_NONE =      0,              /*< No display meter */
00540   RIG_METER_SWR =       (1<<0),         /*< Stationary Wave Ratio */
00541   RIG_METER_COMP =      (1<<1),         /*< Compression level */
00542   RIG_METER_ALC =       (1<<2),         /*< ALC */
00543   RIG_METER_IC =        (1<<3),         /*< IC */
00544   RIG_METER_DB =        (1<<4)          /*< DB */
00545 };
00546 
00551 typedef union {
00552   signed int i;                 
00553   float f;                      
00554   char *s;                      
00555   const char *cs;               
00556 } value_t;
00557 
00559 enum rig_level_e {
00560         RIG_LEVEL_NONE =        0,      
00561         RIG_LEVEL_PREAMP =      (1<<0), 
00562         RIG_LEVEL_ATT =         (1<<1), 
00563         RIG_LEVEL_VOX =         (1<<2), 
00564         RIG_LEVEL_AF =          (1<<3), 
00565         RIG_LEVEL_RF =          (1<<4), 
00566         RIG_LEVEL_SQL =         (1<<5), 
00567         RIG_LEVEL_IF =          (1<<6), 
00568         RIG_LEVEL_APF =         (1<<7), 
00569         RIG_LEVEL_NR =          (1<<8), 
00570         RIG_LEVEL_PBT_IN =      (1<<9), 
00571         RIG_LEVEL_PBT_OUT =     (1<<10),
00572         RIG_LEVEL_CWPITCH =     (1<<11),
00573         RIG_LEVEL_RFPOWER =     (1<<12),
00574         RIG_LEVEL_MICGAIN =     (1<<13),
00575         RIG_LEVEL_KEYSPD =      (1<<14),
00576         RIG_LEVEL_NOTCHF =      (1<<15),
00577         RIG_LEVEL_COMP =        (1<<16),
00578         RIG_LEVEL_AGC =         (1<<17),
00579         RIG_LEVEL_BKINDL =      (1<<18),
00580         RIG_LEVEL_BALANCE =     (1<<19),
00581         RIG_LEVEL_METER =       (1<<20),
00583         RIG_LEVEL_VOXGAIN =     (1<<21),
00584         RIG_LEVEL_VOXDELAY =  RIG_LEVEL_VOX,    
00585         RIG_LEVEL_ANTIVOX =     (1<<22),
00586         //RIG_LEVEL_LINEOUT =   (1<<23),/*!< Lineout Volume, arg float [0.0 .. 1.0] */
00587 
00589         RIG_LEVEL_RAWSTR =      (1<<26),
00590         RIG_LEVEL_SQLSTAT =     (1<<27),
00591         RIG_LEVEL_SWR =         (1<<28),
00592         RIG_LEVEL_ALC =         (1<<29),
00593         RIG_LEVEL_STRENGTH =    (1<<30) 
00594         /*RIG_LEVEL_BWC =               (1<<31)*/ 
00595 };
00596 
00597 #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)
00598 
00599 #define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR)
00600 
00601 #define RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST)
00602 #define RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST)
00603 
00604 
00609 enum rig_parm_e {
00610         RIG_PARM_NONE =         0,      
00611         RIG_PARM_ANN =          (1<<0), 
00612         RIG_PARM_APO =          (1<<1), 
00613         RIG_PARM_BACKLIGHT =    (1<<2), 
00614         RIG_PARM_BEEP =         (1<<4), 
00615         RIG_PARM_TIME =         (1<<5), 
00616         RIG_PARM_BAT =          (1<<6), 
00617         RIG_PARM_KEYLIGHT =     (1<<7)  
00618 };
00619 
00620 #define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
00621 #define RIG_PARM_READONLY_LIST (RIG_PARM_BAT)
00622 
00623 #define RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST)
00624 #define RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST)
00625 
00626 #define RIG_SETTING_MAX 64
00627 
00633 typedef unsigned long setting_t;
00634 
00635 /*
00636  * tranceive mode, ie. the rig notify the host of any event,
00637  * like freq changed, mode changed, etc.
00638  */
00639 #define RIG_TRN_OFF 0
00640 #define RIG_TRN_RIG 1
00641 #define RIG_TRN_POLL 2
00642 
00643 
00647 enum rig_func_e {
00648         RIG_FUNC_NONE =         0,      
00649         RIG_FUNC_FAGC =         (1<<0), 
00650         RIG_FUNC_NB =           (1<<1), 
00651         RIG_FUNC_COMP =         (1<<2), 
00652         RIG_FUNC_VOX =          (1<<3), 
00653         RIG_FUNC_TONE =         (1<<4), 
00654         RIG_FUNC_TSQL =         (1<<5), 
00655         RIG_FUNC_SBKIN =        (1<<6), 
00656         RIG_FUNC_FBKIN =        (1<<7), 
00657         RIG_FUNC_ANF =          (1<<8), 
00658         RIG_FUNC_NR =           (1<<9), 
00659         RIG_FUNC_AIP =          (1<<10),
00660         RIG_FUNC_APF =          (1<<11),
00661         RIG_FUNC_MON =          (1<<12),
00662         RIG_FUNC_MN =           (1<<13),
00663         RIG_FUNC_RNF =          (1<<14),
00664         RIG_FUNC_ARO =          (1<<15),
00665         RIG_FUNC_LOCK =         (1<<16),
00666         RIG_FUNC_MUTE =         (1<<17),
00667         RIG_FUNC_VSC =          (1<<18),
00668         RIG_FUNC_REV =          (1<<19),
00669         RIG_FUNC_SQL =          (1<<20),
00670         RIG_FUNC_ABM =          (1<<21),
00671         RIG_FUNC_BC =           (1<<22),
00672         RIG_FUNC_MBC =          (1<<23),
00673         /*                      (1<<24), used to be RIG_FUNC_LMP, see RIG_PARM_BACKLIGHT instead) */
00674         RIG_FUNC_AFC =          (1<<25),
00675         RIG_FUNC_SATMODE =      (1<<26),
00676         RIG_FUNC_SCOPE =        (1<<27),
00677         RIG_FUNC_RESUME =       (1<<28),
00678         RIG_FUNC_TBURST =       (1<<29),
00679         RIG_FUNC_TUNER =        (1<<30) 
00680 };
00681 
00682 /*
00683  * power unit macros, converts to mW
00684  * This is limited to 2MW on 32 bits systems.
00685  */
00686 #define mW(p)    ((int)(p))
00687 #define Watts(p) ((int)((p)*1000))
00688 #define W(p)     Watts(p)
00689 #define kW(p)    ((int)((p)*1000000L))
00690 
00694 typedef enum {
00695         RIG_MODE_NONE =         0,      
00696         RIG_MODE_AM =           (1<<0), 
00697         RIG_MODE_CW =           (1<<1), 
00698         RIG_MODE_USB =          (1<<2), 
00699         RIG_MODE_LSB =          (1<<3), 
00700         RIG_MODE_RTTY =         (1<<4), 
00701         RIG_MODE_FM =           (1<<5), 
00702         RIG_MODE_WFM =          (1<<6), 
00703         RIG_MODE_CWR =          (1<<7), 
00704         RIG_MODE_RTTYR =        (1<<8), 
00705         RIG_MODE_AMS =          (1<<9), 
00706         RIG_MODE_PKTLSB =       (1<<10),
00707         RIG_MODE_PKTUSB =       (1<<11),
00708         RIG_MODE_PKTFM =        (1<<12),
00709         RIG_MODE_ECSSUSB =      (1<<13),
00710         RIG_MODE_ECSSLSB =      (1<<14),
00711         RIG_MODE_FAX =          (1<<15) 
00713 } rmode_t;
00714 
00716 #define RIG_MODE_SSB    (RIG_MODE_USB|RIG_MODE_LSB)
00717 
00719 #define RIG_MODE_ECSS   (RIG_MODE_ECSSUSB|RIG_MODE_ECSSLSB)
00720 
00721 
00722 #define RIG_DBLST_END 0         /* end marker in a preamp/att level list */
00723 #define RIG_IS_DBLST_END(d) ((d)==0)
00724 
00731 typedef struct freq_range_list {
00732   freq_t start;         
00733   freq_t end;           
00734   rmode_t modes;        
00735   int low_power;        
00736   int high_power;       
00737   vfo_t vfo;            
00738   ant_t ant;            
00739 } freq_range_t;
00740 
00741 #define RIG_FRNG_END     {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE}
00742 #define RIG_IS_FRNG_END(r) ((r).start == Hz(0) && (r).end == Hz(0))
00743 
00744 #define RIG_ITU_REGION1 1
00745 #define RIG_ITU_REGION2 2
00746 #define RIG_ITU_REGION3 3
00747 
00767 struct tuning_step_list {
00768   rmode_t modes;        
00769   shortfreq_t ts;       
00770 };
00771 
00772 #define RIG_TS_ANY     0
00773 #define RIG_TS_END     {RIG_MODE_NONE,0}
00774 #define RIG_IS_TS_END(t)        ((t).modes == RIG_MODE_NONE && (t).ts == 0)
00775 
00802 struct filter_list {
00803   rmode_t modes;        
00804   pbwidth_t width;      
00805 };
00806 
00807 #define RIG_FLT_ANY     0
00808 #define RIG_FLT_END     {RIG_MODE_NONE,0}
00809 #define RIG_IS_FLT_END(f)       ((f).modes == RIG_MODE_NONE)
00810 
00811 
00812 /*
00813  * Used in the channel.flags field
00814  */
00815 #define RIG_CHFLAG_NONE 0
00816 #define RIG_CHFLAG_SKIP (1<<0)
00817 
00822 struct ext_list {
00823   token_t token;        
00824   value_t val;          
00825 };
00826 
00827 #define RIG_EXT_END     {0, {.i=0}}
00828 #define RIG_IS_EXT_END(x)       ((x).token == 0)
00829 
00837 struct channel {
00838   int channel_num;              
00839   int bank_num;                 
00840   vfo_t vfo;                    
00841   int ant;                      
00842   freq_t freq;                  
00843   rmode_t mode;                 
00844   pbwidth_t width;              
00846   freq_t tx_freq;               
00847   rmode_t tx_mode;              
00848   pbwidth_t tx_width;           
00850   split_t split;                
00851   vfo_t tx_vfo;                 
00853   rptr_shift_t rptr_shift;      
00854   shortfreq_t rptr_offs;        
00855   shortfreq_t tuning_step;      
00856   shortfreq_t rit;              
00857   shortfreq_t xit;              
00858   setting_t funcs;              
00859   value_t levels[RIG_SETTING_MAX];      
00860   tone_t ctcss_tone;            
00861   tone_t ctcss_sql;             
00862   tone_t dcs_code;              
00863   tone_t dcs_sql;               
00864   int scan_group;               
00865   int flags;                    
00866   char channel_desc[MAXCHANDESC];       
00867   struct ext_list *ext_levels;  
00868 };
00870 typedef struct channel channel_t;
00871 
00877 struct channel_cap {
00878   unsigned bank_num:1;          
00879   unsigned vfo:1;               
00880   unsigned ant:1;               
00881   unsigned freq:1;              
00882   unsigned mode:1;              
00883   unsigned width:1;             
00885   unsigned tx_freq:1;           
00886   unsigned tx_mode:1;           
00887   unsigned tx_width:1;          
00889   unsigned split:1;             
00890   unsigned tx_vfo:1;            
00891   unsigned rptr_shift:1;        
00892   unsigned rptr_offs:1;         
00893   unsigned tuning_step:1;       
00894   unsigned rit:1;               
00895   unsigned xit:1;               
00896   setting_t funcs;              
00897   setting_t levels;             
00898   unsigned ctcss_tone:1;        
00899   unsigned ctcss_sql:1;         
00900   unsigned dcs_code:1;          
00901   unsigned dcs_sql:1;           
00902   unsigned scan_group:1;        
00903   unsigned flags:1;             
00904   unsigned channel_desc:1;      
00905   unsigned ext_levels:1;        
00906 };
00907 
00909 typedef struct channel_cap channel_cap_t;
00910 
00911 
00922 typedef enum {
00923   RIG_MTYPE_NONE=0,             
00924   RIG_MTYPE_MEM,                
00925   RIG_MTYPE_EDGE,               
00926   RIG_MTYPE_CALL,               
00927   RIG_MTYPE_MEMOPAD,            
00928   RIG_MTYPE_SAT                 
00929 } chan_type_t;
00930 
00944 struct chan_list {
00945   int start;                    
00946   int end;                      
00947   chan_type_t type;             
00948   channel_cap_t mem_caps;       
00949 };
00950 
00951 #define RIG_CHAN_END     {0,0,RIG_MTYPE_NONE}
00952 #define RIG_IS_CHAN_END(c)      ((c).type == RIG_MTYPE_NONE)
00953 
00955 typedef struct chan_list chan_t;
00956 
00968 struct gran {
00969         value_t min;            
00970         value_t max;            
00971         value_t step;           
00972 };
00973 
00975 typedef struct gran gran_t;
00976 
00977 
00979 struct cal_table {
00980         int size;       
00981         struct {
00982                 int raw;        
00983                 int val;        
00984         } table[MAX_CAL_LENGTH];        
00985 };
00986 
00999 typedef struct cal_table cal_table_t;
01000 
01001 #define EMPTY_STR_CAL { 0, { { 0, 0 }, } }
01002 
01003 
01022 struct rig_caps {
01023   rig_model_t rig_model;        
01024   const char *model_name;       
01025   const char *mfg_name;         
01026   const char *version;          
01027   const char *copyright;        
01028   enum rig_status_e status;     
01030   int rig_type;                 
01031   ptt_type_t ptt_type;          
01032   dcd_type_t dcd_type;          
01033   rig_port_t port_type;         
01035   int serial_rate_min;          
01036   int serial_rate_max;          
01037   int serial_data_bits;         
01038   int serial_stop_bits;         
01039   enum serial_parity_e serial_parity;           
01040   enum serial_handshake_e serial_handshake;     
01042   int write_delay;              
01043   int post_write_delay;         
01044   int timeout;                  
01045   int retry;                    
01047   setting_t has_get_func;       
01048   setting_t has_set_func;       
01049   setting_t has_get_level;      
01050   setting_t has_set_level;      
01051   setting_t has_get_parm;       
01052   setting_t has_set_parm;       
01054   gran_t level_gran[RIG_SETTING_MAX];   
01055   gran_t parm_gran[RIG_SETTING_MAX];    
01057   const struct confparams *extparms;    
01058   const struct confparams *extlevels;   
01060   const tone_t *ctcss_list;     
01061   const tone_t *dcs_list;       
01063   int preamp[MAXDBLSTSIZ];      
01064   int attenuator[MAXDBLSTSIZ];  
01065   shortfreq_t max_rit;          
01066   shortfreq_t max_xit;          
01067   shortfreq_t max_ifshift;      
01069   ann_t announces;      
01071   vfo_op_t vfo_ops;     
01072   scan_t scan_ops;      
01073   int targetable_vfo;   
01074   int transceive;       
01076   int bank_qty;         
01077   int chan_desc_sz;     
01079   chan_t chan_list[CHANLSTSIZ]; 
01081   freq_range_t rx_range_list1[FRQRANGESIZ];     
01082   freq_range_t tx_range_list1[FRQRANGESIZ];     
01083   freq_range_t rx_range_list2[FRQRANGESIZ];     
01084   freq_range_t tx_range_list2[FRQRANGESIZ];     
01086   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01087   struct filter_list filters[FLTLSTSIZ];                
01089   cal_table_t str_cal;                          
01091   const struct confparams *cfgparams;            
01092   const rig_ptr_t priv;                          
01094         /*
01095          * Rig API
01096          *
01097          */
01098 
01099   int (*rig_init) (RIG * rig);
01100   int (*rig_cleanup) (RIG * rig);
01101   int (*rig_open) (RIG * rig);
01102   int (*rig_close) (RIG * rig);
01103 
01104         /*
01105          *  General API commands, from most primitive to least.. :()
01106          *  List Set/Get functions pairs
01107          */
01108 
01109   int (*set_freq) (RIG * rig, vfo_t vfo, freq_t freq);
01110   int (*get_freq) (RIG * rig, vfo_t vfo, freq_t * freq);
01111 
01112   int (*set_mode) (RIG * rig, vfo_t vfo, rmode_t mode,
01113                          pbwidth_t width);
01114   int (*get_mode) (RIG * rig, vfo_t vfo, rmode_t * mode,
01115                          pbwidth_t * width);
01116 
01117   int (*set_vfo) (RIG * rig, vfo_t vfo);
01118   int (*get_vfo) (RIG * rig, vfo_t * vfo);
01119 
01120   int (*set_ptt) (RIG * rig, vfo_t vfo, ptt_t ptt);
01121   int (*get_ptt) (RIG * rig, vfo_t vfo, ptt_t * ptt);
01122   int (*get_dcd) (RIG * rig, vfo_t vfo, dcd_t * dcd);
01123 
01124   int (*set_rptr_shift) (RIG * rig, vfo_t vfo,
01125                                rptr_shift_t rptr_shift);
01126   int (*get_rptr_shift) (RIG * rig, vfo_t vfo,
01127                                rptr_shift_t * rptr_shift);
01128 
01129   int (*set_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t offs);
01130   int (*get_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t * offs);
01131 
01132   int (*set_split_freq) (RIG * rig, vfo_t vfo, freq_t tx_freq);
01133   int (*get_split_freq) (RIG * rig, vfo_t vfo, freq_t * tx_freq);
01134   int (*set_split_mode) (RIG * rig, vfo_t vfo, rmode_t tx_mode,
01135                                pbwidth_t tx_width);
01136   int (*get_split_mode) (RIG * rig, vfo_t vfo, rmode_t * tx_mode,
01137                                pbwidth_t * tx_width);
01138 
01139   int (*set_split_vfo) (RIG * rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
01140   int (*get_split_vfo) (RIG * rig, vfo_t vfo, split_t * split, vfo_t *tx_vfo);
01141 
01142   int (*set_rit) (RIG * rig, vfo_t vfo, shortfreq_t rit);
01143   int (*get_rit) (RIG * rig, vfo_t vfo, shortfreq_t * rit);
01144   int (*set_xit) (RIG * rig, vfo_t vfo, shortfreq_t xit);
01145   int (*get_xit) (RIG * rig, vfo_t vfo, shortfreq_t * xit);
01146 
01147   int (*set_ts) (RIG * rig, vfo_t vfo, shortfreq_t ts);
01148   int (*get_ts) (RIG * rig, vfo_t vfo, shortfreq_t * ts);
01149 
01150   int (*set_dcs_code) (RIG * rig, vfo_t vfo, tone_t code);
01151   int (*get_dcs_code) (RIG * rig, vfo_t vfo, tone_t * code);
01152   int (*set_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01153   int (*get_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01154   int (*set_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01155   int (*get_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01156 
01157   int (*set_dcs_sql) (RIG * rig, vfo_t vfo, tone_t code);
01158   int (*get_dcs_sql) (RIG * rig, vfo_t vfo, tone_t * code);
01159   int (*set_tone_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01160   int (*get_tone_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01161   int (*set_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01162   int (*get_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01163 
01164   int (*power2mW) (RIG * rig, unsigned int *mwpower, float power,
01165                          freq_t freq, rmode_t mode);
01166   int (*mW2power) (RIG * rig, float *power, unsigned int mwpower,
01167                          freq_t freq, rmode_t mode);
01168 
01169   int (*set_powerstat) (RIG * rig, powerstat_t status);
01170   int (*get_powerstat) (RIG * rig, powerstat_t * status);
01171   int (*reset) (RIG * rig, reset_t reset);
01172 
01173   int (*set_ant) (RIG * rig, vfo_t vfo, ant_t ant);
01174   int (*get_ant) (RIG * rig, vfo_t vfo, ant_t * ant);
01175 
01176   int (*set_level) (RIG * rig, vfo_t vfo, setting_t level,
01177                           value_t val);
01178   int (*get_level) (RIG * rig, vfo_t vfo, setting_t level,
01179                           value_t * val);
01180 
01181   int (*set_func) (RIG * rig, vfo_t vfo, setting_t func, int status);
01182   int (*get_func) (RIG * rig, vfo_t vfo, setting_t func,
01183                          int *status);
01184 
01185   int (*set_parm) (RIG * rig, setting_t parm, value_t val);
01186   int (*get_parm) (RIG * rig, setting_t parm, value_t * val);
01187 
01188   int (*set_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t val);
01189   int (*get_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t *val);
01190 
01191   int (*set_ext_parm)(RIG *rig, token_t token, value_t val);
01192   int (*get_ext_parm)(RIG *rig, token_t token, value_t *val);
01193 
01194   int (*set_conf) (RIG * rig, token_t token, const char *val);
01195   int (*get_conf) (RIG * rig, token_t token, char *val);
01196 
01197   int (*send_dtmf) (RIG * rig, vfo_t vfo, const char *digits);
01198   int (*recv_dtmf) (RIG * rig, vfo_t vfo, char *digits, int *length);
01199   int (*send_morse) (RIG * rig, vfo_t vfo, const char *msg);
01200 
01201   int (*set_bank) (RIG * rig, vfo_t vfo, int bank);
01202   int (*set_mem) (RIG * rig, vfo_t vfo, int ch);
01203   int (*get_mem) (RIG * rig, vfo_t vfo, int *ch);
01204   int (*vfo_op) (RIG * rig, vfo_t vfo, vfo_op_t op);
01205   int (*scan) (RIG * rig, vfo_t vfo, scan_t scan, int ch);
01206 
01207   int (*set_trn) (RIG * rig, int trn);
01208   int (*get_trn) (RIG * rig, int *trn);
01209 
01210   int (*decode_event) (RIG * rig);
01211 
01212   int (*set_channel) (RIG * rig, const channel_t * chan);
01213   int (*get_channel) (RIG * rig, channel_t * chan);
01214 
01215   const char *(*get_info) (RIG * rig);
01216 
01217 };
01218 
01224 typedef struct {
01225   union {
01226         rig_port_t rig;         
01227         ptt_type_t ptt;         
01228         dcd_type_t dcd;         
01229   } type;
01230   int fd;                       
01231 #if defined(__CYGWIN__) || defined(_WIN32)
01232   void* deprecated_handle;      
01233 #endif
01234 
01235   int write_delay;              
01236   int post_write_delay;         
01237   struct { int tv_sec,tv_usec; } post_write_date;       
01238   int timeout;                  
01239   int retry;                    
01241   char pathname[FILPATHLEN];    
01242   union {
01243         struct {
01244                 int rate;       
01245                 int data_bits;  
01246                 int stop_bits;  
01247                 enum serial_parity_e parity;            
01248                 enum serial_handshake_e handshake;      
01249                 enum serial_control_state_e rts_state;  
01250                 enum serial_control_state_e dtr_state;  
01251         } serial;               
01252         struct {
01253                 int pin;        
01254         } parallel;             
01255   } parm;                       
01256 } hamlib_port_t;
01257 
01258 #if !defined(__APPLE__) || !defined(__cplusplus)
01259 typedef hamlib_port_t port_t;
01260 #endif
01261 
01262 
01272 struct rig_state {
01273         /*
01274          * overridable fields
01275          */
01276   hamlib_port_t rigport;        
01277   hamlib_port_t pttport;        
01278   hamlib_port_t dcdport;        
01280   double vfo_comp;      
01282   int itu_region;       
01283   freq_range_t rx_range_list[FRQRANGESIZ];      
01284   freq_range_t tx_range_list[FRQRANGESIZ];      
01286   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01288   struct filter_list filters[FLTLSTSIZ];        
01290   cal_table_t str_cal;                          
01292   chan_t chan_list[CHANLSTSIZ]; 
01294   shortfreq_t max_rit;          
01295   shortfreq_t max_xit;          
01296   shortfreq_t max_ifshift;      
01298   ann_t announces;              
01300   int preamp[MAXDBLSTSIZ];      
01301   int attenuator[MAXDBLSTSIZ];  
01303   setting_t has_get_func;       
01304   setting_t has_set_func;       
01305   setting_t has_get_level;      
01306   setting_t has_set_level;      
01307   setting_t has_get_parm;       
01308   setting_t has_set_parm;       
01310   gran_t level_gran[RIG_SETTING_MAX];   
01311   gran_t parm_gran[RIG_SETTING_MAX];    
01314         /* 
01315          * non overridable fields, internal use
01316          */
01317 
01318   int hold_decode;      
01319   vfo_t current_vfo;    
01320   int vfo_list;         
01321   int comm_state;       
01322   rig_ptr_t priv;       
01323   rig_ptr_t obj;        
01325   int transceive;       
01326   int poll_interval;    
01327   freq_t current_freq;  
01328   rmode_t current_mode; 
01329   pbwidth_t current_width;      
01331 };
01332 
01333 
01334 typedef int (*freq_cb_t) (RIG *, vfo_t, freq_t, rig_ptr_t);
01335 typedef int (*mode_cb_t) (RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t);
01336 typedef int (*vfo_cb_t) (RIG *, vfo_t, rig_ptr_t);
01337 typedef int (*ptt_cb_t) (RIG *, vfo_t, ptt_t, rig_ptr_t);
01338 typedef int (*dcd_cb_t) (RIG *, vfo_t, dcd_t, rig_ptr_t);
01339 typedef int (*pltune_cb_t) (RIG *, vfo_t, freq_t *, rmode_t *, pbwidth_t *, rig_ptr_t);
01340 
01358 struct rig_callbacks {
01359   freq_cb_t freq_event; 
01360   rig_ptr_t freq_arg;   
01361   mode_cb_t mode_event; 
01362   rig_ptr_t mode_arg;   
01363   vfo_cb_t vfo_event;   
01364   rig_ptr_t vfo_arg;    
01365   ptt_cb_t ptt_event;   
01366   rig_ptr_t ptt_arg;    
01367   dcd_cb_t dcd_event;   
01368   rig_ptr_t dcd_arg;    
01369   pltune_cb_t pltune;   
01370   rig_ptr_t pltune_arg; 
01371   /* etc.. */
01372 };
01373 
01383 struct rig {
01384   struct rig_caps *caps;                
01385   struct rig_state state;               
01386   struct rig_callbacks callbacks;       
01387 };
01388 
01389 
01390 
01391 /* --------------- API function prototypes -----------------*/
01392 
01393 extern HAMLIB_EXPORT(RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model));
01394 extern HAMLIB_EXPORT(int) rig_open HAMLIB_PARAMS((RIG *rig));
01395 
01396   /*
01397    *  General API commands, from most primitive to least.. :()
01398    *  List Set/Get functions pairs
01399    */
01400 
01401 extern HAMLIB_EXPORT(int) rig_set_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t freq));
01402 extern HAMLIB_EXPORT(int) rig_get_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *freq));
01403 
01404 extern HAMLIB_EXPORT(int) rig_set_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width));
01405 extern HAMLIB_EXPORT(int) rig_get_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width));
01406 
01407 extern HAMLIB_EXPORT(int) rig_set_vfo HAMLIB_PARAMS((RIG *rig, vfo_t vfo));
01408 extern HAMLIB_EXPORT(int) rig_get_vfo HAMLIB_PARAMS((RIG *rig, vfo_t *vfo));
01409 
01410 extern HAMLIB_EXPORT(int) rig_set_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t ptt));
01411 extern HAMLIB_EXPORT(int) rig_get_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t *ptt));
01412 
01413 extern HAMLIB_EXPORT(int) rig_get_dcd HAMLIB_PARAMS((RIG *rig, vfo_t vfo, dcd_t *dcd));
01414 
01415 extern HAMLIB_EXPORT(int) rig_set_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift));
01416 extern HAMLIB_EXPORT(int) rig_get_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift));
01417 extern HAMLIB_EXPORT(int) rig_set_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rptr_offs));
01418 extern HAMLIB_EXPORT(int) rig_get_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs));
01419 
01420 extern HAMLIB_EXPORT(int) rig_set_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01421 extern HAMLIB_EXPORT(int) rig_get_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01422 extern HAMLIB_EXPORT(int) rig_set_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01423 extern HAMLIB_EXPORT(int) rig_get_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01424 
01425 extern HAMLIB_EXPORT(int) rig_set_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01426 extern HAMLIB_EXPORT(int) rig_get_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01427 extern HAMLIB_EXPORT(int) rig_set_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01428 extern HAMLIB_EXPORT(int) rig_get_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01429 
01430 extern HAMLIB_EXPORT(int) rig_set_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t tx_freq));
01431 extern HAMLIB_EXPORT(int) rig_get_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *tx_freq));
01432 extern HAMLIB_EXPORT(int) rig_set_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width));
01433 extern HAMLIB_EXPORT(int) rig_get_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width));
01434 extern HAMLIB_EXPORT(int) rig_set_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t split, vfo_t tx_vfo));
01435 extern HAMLIB_EXPORT(int) rig_get_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t *split, vfo_t *tx_vfo));
01436 #define rig_set_split(r,v,s) rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR)
01437 #define rig_get_split(r,v,s) ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); })
01438 
01439 extern HAMLIB_EXPORT(int) rig_set_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rit));
01440 extern HAMLIB_EXPORT(int) rig_get_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rit));
01441 extern HAMLIB_EXPORT(int) rig_set_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t xit));
01442 extern HAMLIB_EXPORT(int) rig_get_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *xit));
01443 
01444 extern HAMLIB_EXPORT(int) rig_set_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t ts));
01445 extern HAMLIB_EXPORT(int) rig_get_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *ts));
01446 
01447 extern HAMLIB_EXPORT(int) rig_power2mW HAMLIB_PARAMS((RIG *rig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode));
01448 extern HAMLIB_EXPORT(int) rig_mW2power HAMLIB_PARAMS((RIG *rig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode));
01449 
01450 extern HAMLIB_EXPORT(shortfreq_t) rig_get_resolution HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01451 
01452 extern HAMLIB_EXPORT(int) rig_set_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t val));
01453 extern HAMLIB_EXPORT(int) rig_get_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t *val));
01454 
01455 #define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s))
01456 
01457 extern HAMLIB_EXPORT(int) rig_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t val));
01458 extern HAMLIB_EXPORT(int) rig_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t *val));
01459 
01460 extern HAMLIB_EXPORT(int) rig_set_conf HAMLIB_PARAMS((RIG *rig, token_t token, const char *val));
01461 extern HAMLIB_EXPORT(int) rig_get_conf HAMLIB_PARAMS((RIG *rig, token_t token, char *val));
01462 
01463 extern HAMLIB_EXPORT(int) rig_set_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t status));
01464 extern HAMLIB_EXPORT(int) rig_get_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t *status));
01465 
01466 extern HAMLIB_EXPORT(int) rig_reset HAMLIB_PARAMS((RIG *rig, reset_t reset));   /* dangerous! */
01467 
01468 extern HAMLIB_EXPORT(int) rig_set_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01469                         token_t token, value_t val));
01470 extern HAMLIB_EXPORT(int) rig_get_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01471                         token_t token, value_t *val));
01472 
01473 extern HAMLIB_EXPORT(int) rig_set_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t val));
01474 extern HAMLIB_EXPORT(int) rig_get_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t *val));
01475 
01476 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));
01477 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));
01478 extern HAMLIB_EXPORT(const struct confparams*) rig_ext_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01479 extern HAMLIB_EXPORT(token_t) rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01480 
01481 
01482 extern HAMLIB_EXPORT(int) rig_token_foreach HAMLIB_PARAMS((RIG *rig, int (*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data));
01483 extern HAMLIB_EXPORT(const struct confparams*) rig_confparam_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01484 extern HAMLIB_EXPORT(token_t) rig_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01485 
01486 extern HAMLIB_EXPORT(int) rig_close HAMLIB_PARAMS((RIG *rig));
01487 extern HAMLIB_EXPORT(int) rig_cleanup HAMLIB_PARAMS((RIG *rig));
01488 
01489 extern HAMLIB_EXPORT(int) rig_set_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t ant));  /* antenna */
01490 extern HAMLIB_EXPORT(int) rig_get_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t *ant));
01491 
01492 extern HAMLIB_EXPORT(setting_t) rig_has_get_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01493 extern HAMLIB_EXPORT(setting_t) rig_has_set_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01494 
01495 extern HAMLIB_EXPORT(setting_t) rig_has_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01496 extern HAMLIB_EXPORT(setting_t) rig_has_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01497 
01498 extern HAMLIB_EXPORT(setting_t) rig_has_get_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01499 extern HAMLIB_EXPORT(setting_t) rig_has_set_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01500 
01501 extern HAMLIB_EXPORT(int) rig_set_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int status));
01502 extern HAMLIB_EXPORT(int) rig_get_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int *status));
01503 
01504 extern HAMLIB_EXPORT(int) rig_send_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *digits));
01505 extern HAMLIB_EXPORT(int) rig_recv_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, char *digits, int *length));
01506 extern HAMLIB_EXPORT(int) rig_send_morse HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *msg));
01507 
01508 extern HAMLIB_EXPORT(int) rig_set_bank HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int bank));
01509 extern HAMLIB_EXPORT(int) rig_set_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int ch));
01510 extern HAMLIB_EXPORT(int) rig_get_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int *ch));
01511 extern HAMLIB_EXPORT(int) rig_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_t vfo, vfo_op_t op));
01512 extern HAMLIB_EXPORT(vfo_op_t) rig_has_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_op_t op));
01513 extern HAMLIB_EXPORT(int) rig_scan HAMLIB_PARAMS((RIG *rig, vfo_t vfo, scan_t scan, int ch));
01514 extern HAMLIB_EXPORT(scan_t) rig_has_scan HAMLIB_PARAMS((RIG *rig, scan_t scan));
01515 
01516 extern HAMLIB_EXPORT(int) rig_set_channel HAMLIB_PARAMS((RIG *rig, const channel_t *chan));     /* mem */
01517 extern HAMLIB_EXPORT(int) rig_get_channel HAMLIB_PARAMS((RIG *rig, channel_t *chan));
01518 
01519 extern HAMLIB_EXPORT(int) rig_set_trn HAMLIB_PARAMS((RIG *rig, int trn));
01520 extern HAMLIB_EXPORT(int) rig_get_trn HAMLIB_PARAMS((RIG *rig, int *trn));
01521 extern HAMLIB_EXPORT(int) rig_set_freq_callback HAMLIB_PARAMS((RIG *, freq_cb_t, rig_ptr_t));
01522 extern HAMLIB_EXPORT(int) rig_set_mode_callback HAMLIB_PARAMS((RIG *, mode_cb_t, rig_ptr_t));
01523 extern HAMLIB_EXPORT(int) rig_set_vfo_callback HAMLIB_PARAMS((RIG *, vfo_cb_t, rig_ptr_t));
01524 extern HAMLIB_EXPORT(int) rig_set_ptt_callback HAMLIB_PARAMS((RIG *, ptt_cb_t, rig_ptr_t));
01525 extern HAMLIB_EXPORT(int) rig_set_dcd_callback HAMLIB_PARAMS((RIG *, dcd_cb_t, rig_ptr_t));
01526 extern HAMLIB_EXPORT(int) rig_set_pltune_callback HAMLIB_PARAMS((RIG *, pltune_cb_t, rig_ptr_t));
01527 
01528 extern HAMLIB_EXPORT(const char *) rig_get_info HAMLIB_PARAMS((RIG *rig));
01529 
01530 extern HAMLIB_EXPORT(const struct rig_caps *) rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model));
01531 extern HAMLIB_EXPORT(const freq_range_t *) rig_get_range HAMLIB_PARAMS((const freq_range_t range_list[], freq_t freq, rmode_t mode));
01532 
01533 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_normal HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01534 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_narrow HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01535 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_wide HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01536 
01537 extern HAMLIB_EXPORT(const char *) rigerror HAMLIB_PARAMS((int errnum));
01538 
01539 extern HAMLIB_EXPORT(int) rig_setting2idx HAMLIB_PARAMS((setting_t s));
01540 #define rig_idx2setting(i) (1ULL<<(i))
01541 
01542 /*
01543  * Even if these functions are prefixed with "rig_", they are not rig specific
01544  * Maybe "hamlib_" would have been better. Let me know. --SF
01545  */
01546 extern HAMLIB_EXPORT(void) rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01547 extern HAMLIB_EXPORT(int) rig_need_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01548 extern HAMLIB_EXPORT(void) rig_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level, const char *fmt, ...));
01549 
01550 extern HAMLIB_EXPORT(int) rig_register HAMLIB_PARAMS((const struct rig_caps *caps));
01551 extern HAMLIB_EXPORT(int) rig_unregister HAMLIB_PARAMS((rig_model_t rig_model));
01552 extern HAMLIB_EXPORT(int) rig_list_foreach HAMLIB_PARAMS((int (*cfunc)(const struct rig_caps*, rig_ptr_t), rig_ptr_t data));
01553 extern HAMLIB_EXPORT(int) rig_load_backend HAMLIB_PARAMS((const char *be_name));
01554 extern HAMLIB_EXPORT(int) rig_check_backend HAMLIB_PARAMS((rig_model_t rig_model));
01555 extern HAMLIB_EXPORT(int) rig_load_all_backends HAMLIB_PARAMS((void));
01556 
01557 typedef int (*rig_probe_func_t)(const hamlib_port_t *, rig_model_t, rig_ptr_t);
01558 extern HAMLIB_EXPORT(int) rig_probe_all HAMLIB_PARAMS((hamlib_port_t *p, rig_probe_func_t, rig_ptr_t));
01559 extern HAMLIB_EXPORT(rig_model_t) rig_probe HAMLIB_PARAMS((hamlib_port_t *p));
01560 
01561 
01562 /* Misc calls */
01563 extern HAMLIB_EXPORT(const char *) rig_strrmode(rmode_t mode);
01564 extern HAMLIB_EXPORT(const char *) rig_strvfo(vfo_t vfo);
01565 extern HAMLIB_EXPORT(const char *) rig_strfunc(setting_t);
01566 extern HAMLIB_EXPORT(const char *) rig_strlevel(setting_t);
01567 extern HAMLIB_EXPORT(const char *) rig_strparm(setting_t);
01568 extern HAMLIB_EXPORT(const char *) rig_strptrshift(rptr_shift_t);
01569 extern HAMLIB_EXPORT(const char *) rig_strvfop(vfo_op_t op);
01570 extern HAMLIB_EXPORT(const char *) rig_strscan(scan_t scan);
01571 extern HAMLIB_EXPORT(const char *) rig_strstatus(enum rig_status_e status);
01572 
01573 extern HAMLIB_EXPORT(rmode_t) rig_parse_mode(const char *s);
01574 extern HAMLIB_EXPORT(vfo_t) rig_parse_vfo(const char *s);
01575 extern HAMLIB_EXPORT(setting_t) rig_parse_func(const char *s);
01576 extern HAMLIB_EXPORT(setting_t) rig_parse_level(const char *s);
01577 extern HAMLIB_EXPORT(setting_t) rig_parse_parm(const char *s);
01578 extern HAMLIB_EXPORT(vfo_op_t) rig_parse_vfo_op(const char *s);
01579 extern HAMLIB_EXPORT(scan_t) rig_parse_scan(const char *s);
01580 extern HAMLIB_EXPORT(rptr_shift_t) rig_parse_rptr_shift(const char *s);
01581 
01582 
01583 __END_DECLS
01584 
01585 #endif /* _RIG_H */

Generated on Mon Nov 28 19:27:02 2005 for Hamlib - the C library reference by  doxygen 1.4.5