Hamlib  1.2.14
rig.h
Go to the documentation of this file.
00001 /*
00002  *  Hamlib Interface - API header
00003  *  Copyright (c) 2000-2003 by Frank Singleton
00004  *  Copyright (c) 2000-2011 by Stephane Fillod
00005  *
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 
00024 #ifndef _RIG_H
00025 #define _RIG_H 1
00026 
00027 #include <stdio.h>
00028 #include <stdarg.h>
00029 
00030 #include <hamlib/riglist.h>     /* list in another file to not mess up w/ this one */
00031 
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 
00084 enum rig_errcode_e {
00085         RIG_OK=0,               
00086         RIG_EINVAL,             
00087         RIG_ECONF,              
00088         RIG_ENOMEM,             
00089         RIG_ENIMPL,             
00090         RIG_ETIMEOUT,           
00091         RIG_EIO,                
00092         RIG_EINTERNAL,          
00093         RIG_EPROTO,             
00094         RIG_ERJCTED,            
00095         RIG_ETRUNC,             
00096         RIG_ENAVAIL,            
00097         RIG_ENTARGET,           
00098         RIG_BUSERROR,           
00099         RIG_BUSBUSY,            
00100         RIG_EARG,               
00101         RIG_EVFO,               
00102         RIG_EDOM                
00103 };
00104 
00106 #define NETRIGCTL_RET "RPRT "
00107 
00115 enum rig_debug_level_e {
00116   RIG_DEBUG_NONE = 0,           
00117   RIG_DEBUG_BUG,                
00118   RIG_DEBUG_ERR,                
00119   RIG_DEBUG_WARN,               
00120   RIG_DEBUG_VERBOSE,            
00121   RIG_DEBUG_TRACE               
00122 };
00123 
00124 /* --------------- Rig capabilities -----------------*/
00125 
00126 /* Forward struct references */
00127 
00128 struct rig;
00129 struct rig_state;
00130 
00134 typedef struct rig RIG;
00135 
00136 #define RIGNAMSIZ 30
00137 #define RIGVERSIZ 8
00138 #define FILPATHLEN 100
00139 #define FRQRANGESIZ 30
00140 #define MAXCHANDESC 30          /* describe channel eg: "WWV 5Mhz" */
00141 #define TSLSTSIZ 20             /* max tuning step list size, zero ended */
00142 #define FLTLSTSIZ 42            /* max mode/filter list size, zero ended */
00143 #define MAXDBLSTSIZ 8           /* max preamp/att levels supported, zero ended */
00144 #define CHANLSTSIZ 16           /* max mem_list size, zero ended */
00145 #define MAX_CAL_LENGTH 32       /* max calibration plots in cal_table_t */
00146 
00147 
00158 typedef unsigned int tone_t;
00159 
00163 typedef enum rig_port_e {
00164   RIG_PORT_NONE = 0,            
00165   RIG_PORT_SERIAL,              
00166   RIG_PORT_NETWORK,             
00167   RIG_PORT_DEVICE,              
00168   RIG_PORT_PACKET,              
00169   RIG_PORT_DTMF,                
00170   RIG_PORT_ULTRA,               
00171   RIG_PORT_RPC,                 
00172   RIG_PORT_PARALLEL,            
00173   RIG_PORT_USB                  
00174 } rig_port_t;
00175 
00179 enum serial_parity_e {
00180   RIG_PARITY_NONE = 0,          
00181   RIG_PARITY_ODD,               
00182   RIG_PARITY_EVEN,              
00183   RIG_PARITY_MARK,              
00184   RIG_PARITY_SPACE              
00185 };
00186 
00190 enum serial_handshake_e {
00191   RIG_HANDSHAKE_NONE = 0,       
00192   RIG_HANDSHAKE_XONXOFF,        
00193   RIG_HANDSHAKE_HARDWARE        
00194 };
00195 
00196 
00200 enum serial_control_state_e {
00201   RIG_SIGNAL_UNSET = 0, 
00202   RIG_SIGNAL_ON,        
00203   RIG_SIGNAL_OFF        
00204 };
00205 
00207 typedef enum {
00208         RIG_FLAG_RECEIVER =     (1<<1),         
00209         RIG_FLAG_TRANSMITTER =  (1<<2),         
00210         RIG_FLAG_SCANNER =      (1<<3),         
00212         RIG_FLAG_MOBILE =       (1<<4),         
00213         RIG_FLAG_HANDHELD =     (1<<5),         
00214         RIG_FLAG_COMPUTER =     (1<<6),         
00215         RIG_FLAG_TRUNKING =     (1<<7),         
00216         RIG_FLAG_APRS =         (1<<8),         
00217         RIG_FLAG_TNC =          (1<<9),         
00218         RIG_FLAG_DXCLUSTER =    (1<<10),        
00219         RIG_FLAG_TUNER =        (1<<11)         
00220 } rig_type_t;
00221 
00222 #define RIG_FLAG_TRANSCEIVER (RIG_FLAG_RECEIVER|RIG_FLAG_TRANSMITTER)
00223 #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)
00224 
00225 #define RIG_TYPE_OTHER          0
00226 #define RIG_TYPE_TRANSCEIVER    RIG_FLAG_TRANSCEIVER
00227 #define RIG_TYPE_HANDHELD       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_HANDHELD)
00228 #define RIG_TYPE_MOBILE         (RIG_FLAG_TRANSCEIVER|RIG_FLAG_MOBILE)
00229 #define RIG_TYPE_RECEIVER       RIG_FLAG_RECEIVER
00230 #define RIG_TYPE_PCRECEIVER     (RIG_FLAG_COMPUTER|RIG_FLAG_RECEIVER)
00231 #define RIG_TYPE_SCANNER        (RIG_FLAG_SCANNER|RIG_FLAG_RECEIVER)
00232 #define RIG_TYPE_TRUNKSCANNER   (RIG_TYPE_SCANNER|RIG_FLAG_TRUNKING)
00233 #define RIG_TYPE_COMPUTER       (RIG_FLAG_TRANSCEIVER|RIG_FLAG_COMPUTER)
00234 #define RIG_TYPE_TUNER          RIG_FLAG_TUNER
00235 
00236 
00240 enum rig_status_e {
00241   RIG_STATUS_ALPHA = 0,         
00242   RIG_STATUS_UNTESTED,          
00243   RIG_STATUS_BETA,              
00244   RIG_STATUS_STABLE,            
00245   RIG_STATUS_BUGGY              
00246 /*  RIG_STATUS_NEW      *       *!< Initial release of code 
00247  *                              !! Use of RIG_STATUS_NEW is deprecated. Do not use it anymore */
00248 };
00249 
00251 #define RIG_STATUS_NEW RIG_STATUS_UNTESTED
00252 
00256 typedef enum {
00257   RIG_RPT_SHIFT_NONE = 0,       
00258   RIG_RPT_SHIFT_MINUS,          
00259   RIG_RPT_SHIFT_PLUS            
00260 } rptr_shift_t;
00261 
00265 typedef enum {
00266   RIG_SPLIT_OFF = 0,            
00267   RIG_SPLIT_ON                  
00268 } split_t;
00269 
00274 typedef double freq_t;
00276 #define PRIfreq "f"
00277 
00278 #define SCNfreq "lf"
00279 #define FREQFMT SCNfreq
00280 
00285 typedef signed long shortfreq_t;
00286 
00287 #define Hz(f)   ((freq_t)(f))
00288 #define kHz(f)  ((freq_t)((f)*(freq_t)1000))
00289 #define MHz(f)  ((freq_t)((f)*(freq_t)1000000))
00290 #define GHz(f)  ((freq_t)((f)*(freq_t)1000000000))
00291 
00292 #define s_Hz(f)         ((shortfreq_t)(f))
00293 #define s_kHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000))
00294 #define s_MHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000000))
00295 #define s_GHz(f)        ((shortfreq_t)((f)*(shortfreq_t)1000000000))
00296 
00297 #define RIG_FREQ_NONE Hz(0)
00298 
00299 
00315 typedef int vfo_t;
00316 
00318 #define RIG_VFO_NONE    0
00319 
00320 #define RIG_VFO_TX_FLAG    (1<<30)
00321 
00323 #define RIG_VFO_CURR    (1<<29)
00324 
00326 #define RIG_VFO_MEM     (1<<28)
00327 
00329 #define RIG_VFO_VFO     (1<<27)
00330 
00331 #define RIG_VFO_TX_VFO(v)       ((v)|RIG_VFO_TX_FLAG)
00332 
00334 #define RIG_VFO_TX      RIG_VFO_TX_VFO(RIG_VFO_CURR)
00335 
00337 #define RIG_VFO_RX      RIG_VFO_CURR
00338 
00340 #define RIG_VFO_MAIN    (1<<26)
00341 
00342 #define RIG_VFO_SUB     (1<<25)
00343 
00344 #define RIG_VFO_N(n) (1<<(n))
00345 
00347 #define RIG_VFO_A RIG_VFO_N(0)
00348 
00349 #define RIG_VFO_B RIG_VFO_N(1)
00350 
00351 #define RIG_VFO_C RIG_VFO_N(2)
00352 
00353 
00354 /*
00355  * targetable bitfields, for internal use.
00356  * RIG_TARGETABLE_PURE means a pure targetable radio on every command
00357  */
00358 #define RIG_TARGETABLE_NONE 0
00359 #define RIG_TARGETABLE_FREQ (1<<0)
00360 #define RIG_TARGETABLE_MODE (1<<1)
00361 #define RIG_TARGETABLE_PURE (1<<2)
00362 #define RIG_TARGETABLE_TONE (1<<3)
00363 #define RIG_TARGETABLE_FUNC (1<<4)
00364 #define RIG_TARGETABLE_ALL  0x7fffffff
00365 
00366 
00367 #define RIG_PASSBAND_NORMAL s_Hz(0)
00368 
00372 typedef shortfreq_t pbwidth_t;
00373 
00374 
00378 typedef enum dcd_e {
00379   RIG_DCD_OFF = 0,              
00380   RIG_DCD_ON                    
00381 } dcd_t;
00382 
00387 typedef enum {
00388   RIG_DCD_NONE = 0,             
00389   RIG_DCD_RIG,                  
00390   RIG_DCD_SERIAL_DSR,           
00391   RIG_DCD_SERIAL_CTS,           
00392   RIG_DCD_SERIAL_CAR,           
00393   RIG_DCD_PARALLEL              
00394 } dcd_type_t;
00395 
00396 
00400 typedef enum {
00401   RIG_PTT_OFF = 0,              
00402   RIG_PTT_ON,                   
00403   RIG_PTT_ON_MIC,               
00404   RIG_PTT_ON_DATA               
00405 } ptt_t;
00406 
00411 typedef enum {
00412   RIG_PTT_NONE = 0,             
00413   RIG_PTT_RIG,                  
00414   RIG_PTT_SERIAL_DTR,           
00415   RIG_PTT_SERIAL_RTS,           
00416   RIG_PTT_PARALLEL,             
00417   RIG_PTT_RIG_MICDATA           
00418 } ptt_type_t;
00419 
00423 typedef enum {
00424   RIG_POWER_OFF =       0,              
00425   RIG_POWER_ON =        (1<<0),         
00426   RIG_POWER_STANDBY =   (1<<1)          
00427 } powerstat_t;
00428 
00432 typedef enum {
00433   RIG_RESET_NONE =       0,             
00434   RIG_RESET_SOFT =      (1<<0),         
00435   RIG_RESET_VFO =       (1<<1),         
00436   RIG_RESET_MCALL =     (1<<2),         
00437   RIG_RESET_MASTER =    (1<<3)          
00438 } reset_t;
00439 
00440 
00456 typedef enum {
00457         RIG_OP_NONE =           0,  
00458         RIG_OP_CPY =            (1<<0), 
00459         RIG_OP_XCHG =           (1<<1), 
00460         RIG_OP_FROM_VFO =       (1<<2), 
00461         RIG_OP_TO_VFO =         (1<<3), 
00462         RIG_OP_MCL =            (1<<4), 
00463         RIG_OP_UP =             (1<<5), 
00464         RIG_OP_DOWN =           (1<<6), 
00465         RIG_OP_BAND_UP =        (1<<7), 
00466         RIG_OP_BAND_DOWN =      (1<<8), 
00467         RIG_OP_LEFT =           (1<<9), 
00468         RIG_OP_RIGHT =          (1<<10),
00469         RIG_OP_TUNE =           (1<<11),
00470         RIG_OP_TOGGLE =         (1<<12) 
00471 } vfo_op_t;
00472 
00473 
00482 typedef enum {
00483         RIG_SCAN_NONE =         0,  
00484         RIG_SCAN_STOP =         RIG_SCAN_NONE, 
00485         RIG_SCAN_MEM =          (1<<0), 
00486         RIG_SCAN_SLCT =         (1<<1), 
00487         RIG_SCAN_PRIO =         (1<<2), 
00488         RIG_SCAN_PROG =         (1<<3), 
00489         RIG_SCAN_DELTA =        (1<<4), 
00490         RIG_SCAN_VFO =          (1<<5), 
00491         RIG_SCAN_PLT =          (1<<6)  
00492 } scan_t;
00493 
00497 typedef long token_t;
00498 
00499 #define RIG_CONF_END 0
00500 
00513 /* strongly inspired from soundmodem. Thanks Thomas! */
00514 
00515 enum rig_conf_e {
00516         RIG_CONF_STRING,        
00517         RIG_CONF_COMBO,         
00518         RIG_CONF_NUMERIC,       
00519         RIG_CONF_CHECKBUTTON,   
00520         RIG_CONF_BUTTON         
00521 };
00522 
00523 #define RIG_COMBO_MAX   8
00524 
00528 struct confparams {
00529   token_t token;                
00530   const char *name;             
00531   const char *label;            
00532   const char *tooltip;          
00533   const char *dflt;             
00534   enum rig_conf_e type;         
00535   union {                       
00536         struct {                
00537                 float min;      
00538                 float max;      
00539                 float step;     
00540         } n;                    
00541         struct {                
00542                 const char *combostr[RIG_COMBO_MAX];    
00543         } c;                    
00544   } u;                          
00545 };
00546 
00551 typedef enum {
00552         RIG_ANN_NONE =  0,              
00553         RIG_ANN_OFF =   RIG_ANN_NONE,   
00554         RIG_ANN_FREQ =  (1<<0),         
00555         RIG_ANN_RXMODE = (1<<1),        
00556         RIG_ANN_CW = (1<<2),            
00557         RIG_ANN_ENG = (1<<3),           
00558         RIG_ANN_JAP = (1<<4)            
00559 } ann_t;
00560 
00561 
00565 typedef int ant_t;
00566 
00567 #define RIG_ANT_NONE    0
00568 #define RIG_ANT_N(n)    ((ant_t)1<<(n))
00569 #define RIG_ANT_1       RIG_ANT_N(0)
00570 #define RIG_ANT_2       RIG_ANT_N(1)
00571 #define RIG_ANT_3       RIG_ANT_N(2)
00572 #define RIG_ANT_4       RIG_ANT_N(3)
00573 #define RIG_ANT_5       RIG_ANT_N(4)
00574 
00578 /* TODO: kill me, and replace by real AGC delay */
00579 enum agc_level_e {
00580         RIG_AGC_OFF = 0,
00581         RIG_AGC_SUPERFAST,
00582         RIG_AGC_FAST,
00583         RIG_AGC_SLOW,
00584         RIG_AGC_USER,           
00585         RIG_AGC_MEDIUM,
00586         RIG_AGC_AUTO
00587 };
00588 
00592 enum meter_level_e {
00593   RIG_METER_NONE =      0,              /*< No display meter */
00594   RIG_METER_SWR =       (1<<0),         /*< Stationary Wave Ratio */
00595   RIG_METER_COMP =      (1<<1),         /*< Compression level */
00596   RIG_METER_ALC =       (1<<2),         /*< ALC */
00597   RIG_METER_IC =        (1<<3),         /*< IC */
00598   RIG_METER_DB =        (1<<4),         /*< DB */
00599   RIG_METER_PO =        (1<<5),         /*< Power Out */
00600   RIG_METER_VDD =       (1<<6)          /*< Final Amp Voltage */
00601 };
00602 
00607 typedef union {
00608   signed int i;                 
00609   float f;                      
00610   char *s;                      
00611   const char *cs;               
00612 } value_t;
00613 
00622 enum rig_level_e {
00623         RIG_LEVEL_NONE =        0,      
00624         RIG_LEVEL_PREAMP =      (1<<0), 
00625         RIG_LEVEL_ATT =         (1<<1), 
00626         RIG_LEVEL_VOX =         (1<<2), 
00627         RIG_LEVEL_AF =          (1<<3), 
00628         RIG_LEVEL_RF =          (1<<4), 
00629         RIG_LEVEL_SQL =         (1<<5), 
00630         RIG_LEVEL_IF =          (1<<6), 
00631         RIG_LEVEL_APF =         (1<<7), 
00632         RIG_LEVEL_NR =          (1<<8), 
00633         RIG_LEVEL_PBT_IN =      (1<<9), 
00634         RIG_LEVEL_PBT_OUT =     (1<<10),
00635         RIG_LEVEL_CWPITCH =     (1<<11),
00636         RIG_LEVEL_RFPOWER =     (1<<12),
00637         RIG_LEVEL_MICGAIN =     (1<<13),
00638         RIG_LEVEL_KEYSPD =      (1<<14),
00639         RIG_LEVEL_NOTCHF =      (1<<15),
00640         RIG_LEVEL_COMP =        (1<<16),
00641         RIG_LEVEL_AGC =         (1<<17),
00642         RIG_LEVEL_BKINDL =      (1<<18),
00643         RIG_LEVEL_BALANCE =     (1<<19),
00644         RIG_LEVEL_METER =       (1<<20),
00646         RIG_LEVEL_VOXGAIN =     (1<<21),
00647         RIG_LEVEL_VOXDELAY =  RIG_LEVEL_VOX,    
00648         RIG_LEVEL_ANTIVOX =     (1<<22),
00649         RIG_LEVEL_SLOPE_LOW = (1<<23),
00650         RIG_LEVEL_SLOPE_HIGH = (1<<24),
00651         RIG_LEVEL_BKIN_DLYMS = (1<<25),
00654         RIG_LEVEL_RAWSTR =      (1<<26),
00655         RIG_LEVEL_SQLSTAT =     (1<<27),
00656         RIG_LEVEL_SWR =         (1<<28),
00657         RIG_LEVEL_ALC =         (1<<29),
00658         RIG_LEVEL_STRENGTH =(1<<30) 
00659         /*RIG_LEVEL_BWC =               (1<<31)*/ 
00660 };
00661 
00662 #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)
00663 
00664 #define RIG_LEVEL_READONLY_LIST (RIG_LEVEL_SQLSTAT|RIG_LEVEL_SWR|RIG_LEVEL_ALC|RIG_LEVEL_STRENGTH|RIG_LEVEL_RAWSTR)
00665 
00666 #define RIG_LEVEL_IS_FLOAT(l) ((l)&RIG_LEVEL_FLOAT_LIST)
00667 #define RIG_LEVEL_SET(l) ((l)&~RIG_LEVEL_READONLY_LIST)
00668 
00669 
00678 enum rig_parm_e {
00679         RIG_PARM_NONE =         0,      
00680         RIG_PARM_ANN =          (1<<0), 
00681         RIG_PARM_APO =          (1<<1), 
00682         RIG_PARM_BACKLIGHT =    (1<<2), 
00683         RIG_PARM_BEEP =         (1<<4), 
00684         RIG_PARM_TIME =         (1<<5), 
00685         RIG_PARM_BAT =          (1<<6), 
00686         RIG_PARM_KEYLIGHT =     (1<<7)  
00687 };
00688 
00689 #define RIG_PARM_FLOAT_LIST (RIG_PARM_BACKLIGHT|RIG_PARM_BAT)
00690 #define RIG_PARM_READONLY_LIST (RIG_PARM_BAT)
00691 
00692 #define RIG_PARM_IS_FLOAT(l) ((l)&RIG_PARM_FLOAT_LIST)
00693 #define RIG_PARM_SET(l) ((l)&~RIG_PARM_READONLY_LIST)
00694 
00695 #define RIG_SETTING_MAX 32
00696 
00702 typedef unsigned long setting_t;
00703 
00704 /*
00705  * tranceive mode, ie. the rig notify the host of any event,
00706  * like freq changed, mode changed, etc.
00707  */
00708 #define RIG_TRN_OFF 0
00709 #define RIG_TRN_RIG 1
00710 #define RIG_TRN_POLL 2
00711 
00712 
00721 enum rig_func_e {
00722         RIG_FUNC_NONE =         0,      
00723         RIG_FUNC_FAGC =         (1<<0), 
00724         RIG_FUNC_NB =           (1<<1), 
00725         RIG_FUNC_COMP =         (1<<2), 
00726         RIG_FUNC_VOX =          (1<<3), 
00727         RIG_FUNC_TONE =         (1<<4), 
00728         RIG_FUNC_TSQL =         (1<<5), 
00729         RIG_FUNC_SBKIN =        (1<<6), 
00730         RIG_FUNC_FBKIN =        (1<<7), 
00731         RIG_FUNC_ANF =          (1<<8), 
00732         RIG_FUNC_NR =           (1<<9), 
00733         RIG_FUNC_AIP =          (1<<10),
00734         RIG_FUNC_APF =          (1<<11),
00735         RIG_FUNC_MON =          (1<<12),
00736         RIG_FUNC_MN =           (1<<13),
00737         RIG_FUNC_RF =           (1<<14),
00738         RIG_FUNC_ARO =          (1<<15),
00739         RIG_FUNC_LOCK =         (1<<16),
00740         RIG_FUNC_MUTE =         (1<<17),
00741         RIG_FUNC_VSC =          (1<<18),
00742         RIG_FUNC_REV =          (1<<19),
00743         RIG_FUNC_SQL =          (1<<20),
00744         RIG_FUNC_ABM =          (1<<21),
00745         RIG_FUNC_BC =           (1<<22),
00746         RIG_FUNC_MBC =          (1<<23),
00747         /*                      (1<<24), used to be RIG_FUNC_LMP, see RIG_PARM_BACKLIGHT instead) */
00748         RIG_FUNC_AFC =          (1<<25),
00749         RIG_FUNC_SATMODE =      (1<<26),
00750         RIG_FUNC_SCOPE =        (1<<27),
00751         RIG_FUNC_RESUME =       (1<<28),
00752         RIG_FUNC_TBURST =       (1<<29),
00753         RIG_FUNC_TUNER =        (1<<30) 
00754 };
00755 
00756 /*
00757  * power unit macros, converts to mW
00758  * This is limited to 2MW on 32 bits systems.
00759  */
00760 #define mW(p)    ((int)(p))
00761 #define Watts(p) ((int)((p)*1000))
00762 #define W(p)     Watts(p)
00763 #define kW(p)    ((int)((p)*1000000L))
00764 
00773 typedef enum {
00774         RIG_MODE_NONE =         0,      
00775         RIG_MODE_AM =           (1<<0), 
00776         RIG_MODE_CW =           (1<<1), 
00777         RIG_MODE_USB =          (1<<2), 
00778         RIG_MODE_LSB =          (1<<3), 
00779         RIG_MODE_RTTY =         (1<<4), 
00780         RIG_MODE_FM =           (1<<5), 
00781         RIG_MODE_WFM =          (1<<6), 
00782         RIG_MODE_CWR =          (1<<7), 
00783         RIG_MODE_RTTYR =        (1<<8), 
00784         RIG_MODE_AMS =          (1<<9), 
00785         RIG_MODE_PKTLSB =       (1<<10),
00786         RIG_MODE_PKTUSB =       (1<<11),
00787         RIG_MODE_PKTFM =        (1<<12),
00788         RIG_MODE_ECSSUSB =      (1<<13),
00789         RIG_MODE_ECSSLSB =      (1<<14),
00790         RIG_MODE_FAX =          (1<<15),
00791         RIG_MODE_SAM =          (1<<16),
00792         RIG_MODE_SAL =          (1<<17),
00793         RIG_MODE_SAH =          (1<<18),
00794         RIG_MODE_DSB =                  (1<<19), 
00795     RIG_MODE_TESTS_MAX               
00796 } rmode_t;
00797 
00798 
00800 #define RIG_MODE_SSB    (RIG_MODE_USB|RIG_MODE_LSB)
00801 
00803 #define RIG_MODE_ECSS   (RIG_MODE_ECSSUSB|RIG_MODE_ECSSLSB)
00804 
00805 
00806 #define RIG_DBLST_END 0         /* end marker in a preamp/att level list */
00807 #define RIG_IS_DBLST_END(d) ((d)==0)
00808 
00815 typedef struct freq_range_list {
00816   freq_t start;         
00817   freq_t end;           
00818   rmode_t modes;        
00819   int low_power;        
00820   int high_power;       
00821   vfo_t vfo;            
00822   ant_t ant;            
00823 } freq_range_t;
00824 
00825 #define RIG_FRNG_END     {Hz(0),Hz(0),RIG_MODE_NONE,0,0,RIG_VFO_NONE}
00826 #define RIG_IS_FRNG_END(r) ((r).start == Hz(0) && (r).end == Hz(0))
00827 
00828 #define RIG_ITU_REGION1 1
00829 #define RIG_ITU_REGION2 2
00830 #define RIG_ITU_REGION3 3
00831 
00851 struct tuning_step_list {
00852   rmode_t modes;        
00853   shortfreq_t ts;       
00854 };
00855 
00856 #define RIG_TS_ANY     0
00857 #define RIG_TS_END     {RIG_MODE_NONE,0}
00858 #define RIG_IS_TS_END(t)        ((t).modes == RIG_MODE_NONE && (t).ts == 0)
00859 
00886 struct filter_list {
00887   rmode_t modes;        
00888   pbwidth_t width;      
00889 };
00890 
00891 #define RIG_FLT_ANY     0
00892 #define RIG_FLT_END     {RIG_MODE_NONE,0}
00893 #define RIG_IS_FLT_END(f)       ((f).modes == RIG_MODE_NONE)
00894 
00895 
00897 #define RIG_CHFLAG_NONE 0
00898 
00899 #define RIG_CHFLAG_SKIP (1<<0)
00900 
00901 #define RIG_CHFLAG_DATA (1<<1)
00902 
00907 struct ext_list {
00908   token_t token;        
00909   value_t val;          
00910 };
00911 
00912 #define RIG_EXT_END     {0, {.i=0}}
00913 #define RIG_IS_EXT_END(x)       ((x).token == 0)
00914 
00922 struct channel {
00923   int channel_num;              
00924   int bank_num;                 
00925   vfo_t vfo;                    
00926   int ant;                      
00927   freq_t freq;                  
00928   rmode_t mode;                 
00929   pbwidth_t width;              
00931   freq_t tx_freq;               
00932   rmode_t tx_mode;              
00933   pbwidth_t tx_width;           
00935   split_t split;                
00936   vfo_t tx_vfo;                 
00938   rptr_shift_t rptr_shift;      
00939   shortfreq_t rptr_offs;        
00940   shortfreq_t tuning_step;      
00941   shortfreq_t rit;              
00942   shortfreq_t xit;              
00943   setting_t funcs;              
00944   value_t levels[RIG_SETTING_MAX];      
00945   tone_t ctcss_tone;            
00946   tone_t ctcss_sql;             
00947   tone_t dcs_code;              
00948   tone_t dcs_sql;               
00949   int scan_group;               
00950   int flags;                    
00951   char channel_desc[MAXCHANDESC];       
00952   struct ext_list *ext_levels;  
00953 };
00955 typedef struct channel channel_t;
00956 
00962 struct channel_cap {
00963   unsigned bank_num:1;          
00964   unsigned vfo:1;               
00965   unsigned ant:1;               
00966   unsigned freq:1;              
00967   unsigned mode:1;              
00968   unsigned width:1;             
00970   unsigned tx_freq:1;           
00971   unsigned tx_mode:1;           
00972   unsigned tx_width:1;          
00974   unsigned split:1;             
00975   unsigned tx_vfo:1;            
00976   unsigned rptr_shift:1;        
00977   unsigned rptr_offs:1;         
00978   unsigned tuning_step:1;       
00979   unsigned rit:1;               
00980   unsigned xit:1;               
00981   setting_t funcs;              
00982   setting_t levels;             
00983   unsigned ctcss_tone:1;        
00984   unsigned ctcss_sql:1;         
00985   unsigned dcs_code:1;          
00986   unsigned dcs_sql:1;           
00987   unsigned scan_group:1;        
00988   unsigned flags:1;             
00989   unsigned channel_desc:1;      
00990   unsigned ext_levels:1;        
00991 };
00992 
00994 typedef struct channel_cap channel_cap_t;
00995 
00996 
01007 typedef enum {
01008   RIG_MTYPE_NONE=0,             
01009   RIG_MTYPE_MEM,                
01010   RIG_MTYPE_EDGE,               
01011   RIG_MTYPE_CALL,               
01012   RIG_MTYPE_MEMOPAD,            
01013   RIG_MTYPE_SAT,                
01014   RIG_MTYPE_BAND,               
01015   RIG_MTYPE_PRIO                
01016 } chan_type_t;
01017 
01031 struct chan_list {
01032   int start;                    
01033   int end;                      
01034   chan_type_t type;             
01035   channel_cap_t mem_caps;       
01036 };
01037 
01038 #define RIG_CHAN_END     {0,0,RIG_MTYPE_NONE}
01039 #define RIG_IS_CHAN_END(c)      ((c).type == RIG_MTYPE_NONE)
01040 
01041 #define RIG_MEM_CAPS_ALL -1
01042 
01044 typedef struct chan_list chan_t;
01045 
01057 struct gran {
01058         value_t min;            
01059         value_t max;            
01060         value_t step;           
01061 };
01062 
01064 typedef struct gran gran_t;
01065 
01066 
01068 struct cal_table {
01069         int size;               
01070         struct {
01071                 int raw;        
01072                 int val;        
01073         } table[MAX_CAL_LENGTH];        
01074 };
01075 
01088 typedef struct cal_table cal_table_t;
01089 
01090 #define EMPTY_STR_CAL { 0, { { 0, 0 }, } }
01091 
01092 
01093 typedef int (*chan_cb_t) (RIG *, channel_t**, int, const chan_t*, rig_ptr_t);
01094 typedef int (*confval_cb_t) (RIG *, const struct confparams *, value_t *, rig_ptr_t);
01095 
01114 struct rig_caps {
01115   rig_model_t rig_model;        
01116   const char *model_name;       
01117   const char *mfg_name;         
01118   const char *version;          
01119   const char *copyright;        
01120   enum rig_status_e status;     
01122   int rig_type;                 
01123   ptt_type_t ptt_type;          
01124   dcd_type_t dcd_type;          
01125   rig_port_t port_type;         
01127   int serial_rate_min;          
01128   int serial_rate_max;          
01129   int serial_data_bits;         
01130   int serial_stop_bits;         
01131   enum serial_parity_e serial_parity;           
01132   enum serial_handshake_e serial_handshake;     
01134   int write_delay;              
01135   int post_write_delay;         
01136   int timeout;                  
01137   int retry;                    
01139   setting_t has_get_func;       
01140   setting_t has_set_func;       
01141   setting_t has_get_level;      
01142   setting_t has_set_level;      
01143   setting_t has_get_parm;       
01144   setting_t has_set_parm;       
01146   gran_t level_gran[RIG_SETTING_MAX];   
01147   gran_t parm_gran[RIG_SETTING_MAX];    
01149   const struct confparams *extparms;    
01150   const struct confparams *extlevels;   
01152   const tone_t *ctcss_list;     
01153   const tone_t *dcs_list;       
01155   int preamp[MAXDBLSTSIZ];      
01156   int attenuator[MAXDBLSTSIZ];  
01157   shortfreq_t max_rit;          
01158   shortfreq_t max_xit;          
01159   shortfreq_t max_ifshift;      
01161   ann_t announces;      
01163   vfo_op_t vfo_ops;     
01164   scan_t scan_ops;      
01165   int targetable_vfo;   
01166   int transceive;       
01168   int bank_qty;         
01169   int chan_desc_sz;     
01171   chan_t chan_list[CHANLSTSIZ]; 
01173   freq_range_t rx_range_list1[FRQRANGESIZ];     
01174   freq_range_t tx_range_list1[FRQRANGESIZ];     
01175   freq_range_t rx_range_list2[FRQRANGESIZ];     
01176   freq_range_t tx_range_list2[FRQRANGESIZ];     
01178   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01179   struct filter_list filters[FLTLSTSIZ];                
01181   cal_table_t str_cal;                          
01183   const struct confparams *cfgparams;            
01184   const rig_ptr_t priv;                          
01186         /*
01187          * Rig API
01188          *
01189          */
01190 
01191   int (*rig_init) (RIG * rig);
01192   int (*rig_cleanup) (RIG * rig);
01193   int (*rig_open) (RIG * rig);
01194   int (*rig_close) (RIG * rig);
01195 
01196         /*
01197          *  General API commands, from most primitive to least.. :()
01198          *  List Set/Get functions pairs
01199          */
01200 
01201   int (*set_freq) (RIG * rig, vfo_t vfo, freq_t freq);
01202   int (*get_freq) (RIG * rig, vfo_t vfo, freq_t * freq);
01203 
01204   int (*set_mode) (RIG * rig, vfo_t vfo, rmode_t mode,
01205                          pbwidth_t width);
01206   int (*get_mode) (RIG * rig, vfo_t vfo, rmode_t * mode,
01207                          pbwidth_t * width);
01208 
01209   int (*set_vfo) (RIG * rig, vfo_t vfo);
01210   int (*get_vfo) (RIG * rig, vfo_t * vfo);
01211 
01212   int (*set_ptt) (RIG * rig, vfo_t vfo, ptt_t ptt);
01213   int (*get_ptt) (RIG * rig, vfo_t vfo, ptt_t * ptt);
01214   int (*get_dcd) (RIG * rig, vfo_t vfo, dcd_t * dcd);
01215 
01216   int (*set_rptr_shift) (RIG * rig, vfo_t vfo,
01217                                rptr_shift_t rptr_shift);
01218   int (*get_rptr_shift) (RIG * rig, vfo_t vfo,
01219                                rptr_shift_t * rptr_shift);
01220 
01221   int (*set_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t offs);
01222   int (*get_rptr_offs) (RIG * rig, vfo_t vfo, shortfreq_t * offs);
01223 
01224   int (*set_split_freq) (RIG * rig, vfo_t vfo, freq_t tx_freq);
01225   int (*get_split_freq) (RIG * rig, vfo_t vfo, freq_t * tx_freq);
01226   int (*set_split_mode) (RIG * rig, vfo_t vfo, rmode_t tx_mode,
01227                                pbwidth_t tx_width);
01228   int (*get_split_mode) (RIG * rig, vfo_t vfo, rmode_t * tx_mode,
01229                                pbwidth_t * tx_width);
01230 
01231   int (*set_split_vfo) (RIG * rig, vfo_t vfo, split_t split, vfo_t tx_vfo);
01232   int (*get_split_vfo) (RIG * rig, vfo_t vfo, split_t * split, vfo_t *tx_vfo);
01233 
01234   int (*set_rit) (RIG * rig, vfo_t vfo, shortfreq_t rit);
01235   int (*get_rit) (RIG * rig, vfo_t vfo, shortfreq_t * rit);
01236   int (*set_xit) (RIG * rig, vfo_t vfo, shortfreq_t xit);
01237   int (*get_xit) (RIG * rig, vfo_t vfo, shortfreq_t * xit);
01238 
01239   int (*set_ts) (RIG * rig, vfo_t vfo, shortfreq_t ts);
01240   int (*get_ts) (RIG * rig, vfo_t vfo, shortfreq_t * ts);
01241 
01242   int (*set_dcs_code) (RIG * rig, vfo_t vfo, tone_t code);
01243   int (*get_dcs_code) (RIG * rig, vfo_t vfo, tone_t * code);
01244   int (*set_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01245   int (*get_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01246   int (*set_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t tone);
01247   int (*get_ctcss_tone) (RIG * rig, vfo_t vfo, tone_t * tone);
01248 
01249   int (*set_dcs_sql) (RIG * rig, vfo_t vfo, tone_t code);
01250   int (*get_dcs_sql) (RIG * rig, vfo_t vfo, tone_t * code);
01251   int (*set_tone_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01252   int (*get_tone_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01253   int (*set_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t tone);
01254   int (*get_ctcss_sql) (RIG * rig, vfo_t vfo, tone_t * tone);
01255 
01256   int (*power2mW) (RIG * rig, unsigned int *mwpower, float power,
01257                          freq_t freq, rmode_t mode);
01258   int (*mW2power) (RIG * rig, float *power, unsigned int mwpower,
01259                          freq_t freq, rmode_t mode);
01260 
01261   int (*set_powerstat) (RIG * rig, powerstat_t status);
01262   int (*get_powerstat) (RIG * rig, powerstat_t * status);
01263   int (*reset) (RIG * rig, reset_t reset);
01264 
01265   int (*set_ant) (RIG * rig, vfo_t vfo, ant_t ant);
01266   int (*get_ant) (RIG * rig, vfo_t vfo, ant_t * ant);
01267 
01268   int (*set_level) (RIG * rig, vfo_t vfo, setting_t level,
01269                           value_t val);
01270   int (*get_level) (RIG * rig, vfo_t vfo, setting_t level,
01271                           value_t * val);
01272 
01273   int (*set_func) (RIG * rig, vfo_t vfo, setting_t func, int status);
01274   int (*get_func) (RIG * rig, vfo_t vfo, setting_t func,
01275                          int *status);
01276 
01277   int (*set_parm) (RIG * rig, setting_t parm, value_t val);
01278   int (*get_parm) (RIG * rig, setting_t parm, value_t * val);
01279 
01280   int (*set_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t val);
01281   int (*get_ext_level)(RIG *rig, vfo_t vfo, token_t token, value_t *val);
01282 
01283   int (*set_ext_parm)(RIG *rig, token_t token, value_t val);
01284   int (*get_ext_parm)(RIG *rig, token_t token, value_t *val);
01285 
01286   int (*set_conf) (RIG * rig, token_t token, const char *val);
01287   int (*get_conf) (RIG * rig, token_t token, char *val);
01288 
01289   int (*send_dtmf) (RIG * rig, vfo_t vfo, const char *digits);
01290   int (*recv_dtmf) (RIG * rig, vfo_t vfo, char *digits, int *length);
01291   int (*send_morse) (RIG * rig, vfo_t vfo, const char *msg);
01292 
01293   int (*set_bank) (RIG * rig, vfo_t vfo, int bank);
01294   int (*set_mem) (RIG * rig, vfo_t vfo, int ch);
01295   int (*get_mem) (RIG * rig, vfo_t vfo, int *ch);
01296   int (*vfo_op) (RIG * rig, vfo_t vfo, vfo_op_t op);
01297   int (*scan) (RIG * rig, vfo_t vfo, scan_t scan, int ch);
01298 
01299   int (*set_trn) (RIG * rig, int trn);
01300   int (*get_trn) (RIG * rig, int *trn);
01301 
01302   int (*decode_event) (RIG * rig);
01303 
01304   int (*set_channel) (RIG * rig, const channel_t * chan);
01305   int (*get_channel) (RIG * rig, channel_t * chan);
01306 
01307   const char *(*get_info) (RIG * rig);
01308 
01309   int (*set_chan_all_cb) (RIG * rig, chan_cb_t chan_cb, rig_ptr_t);
01310   int (*get_chan_all_cb) (RIG * rig, chan_cb_t chan_cb, rig_ptr_t);
01311 
01312   int (*set_mem_all_cb) (RIG * rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t);
01313   int (*get_mem_all_cb) (RIG * rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t);
01314 
01315   const char *clone_combo_set;  
01316   const char *clone_combo_get;  
01317 };
01318 
01324 typedef struct {
01325   union {
01326         rig_port_t rig;         
01327         ptt_type_t ptt;         
01328         dcd_type_t dcd;         
01329   } type;
01330   int fd;                       
01331   void* handle;                 
01333   int write_delay;              
01334   int post_write_delay;         
01335   struct { int tv_sec,tv_usec; } post_write_date;       
01336   int timeout;                  
01337   int retry;                    
01339   char pathname[FILPATHLEN];    
01340   union {
01341         struct {
01342                 int rate;       
01343                 int data_bits;  
01344                 int stop_bits;  
01345                 enum serial_parity_e parity;            
01346                 enum serial_handshake_e handshake;      
01347                 enum serial_control_state_e rts_state;  
01348                 enum serial_control_state_e dtr_state;  
01349         } serial;               
01350         struct {
01351                 int pin;        
01352         } parallel;             
01353         struct {
01354                 int vid;        
01355                 int pid;        
01356                 int conf;       
01357                 int iface;      
01358                 int alt;        
01359         char *vendor_name; 
01360         char *product;     
01361         } usb;                  
01362   } parm;                       
01363 } hamlib_port_t;
01364 
01365 #if !defined(__APPLE__) || !defined(__cplusplus)
01366 typedef hamlib_port_t port_t;
01367 #endif
01368 
01369 
01379 struct rig_state {
01380         /*
01381          * overridable fields
01382          */
01383   hamlib_port_t rigport;        
01384   hamlib_port_t pttport;        
01385   hamlib_port_t dcdport;        
01387   double vfo_comp;      
01389   int itu_region;       
01390   freq_range_t rx_range_list[FRQRANGESIZ];      
01391   freq_range_t tx_range_list[FRQRANGESIZ];      
01393   struct tuning_step_list tuning_steps[TSLSTSIZ];       
01395   struct filter_list filters[FLTLSTSIZ];        
01397   cal_table_t str_cal;                          
01399   chan_t chan_list[CHANLSTSIZ]; 
01401   shortfreq_t max_rit;          
01402   shortfreq_t max_xit;          
01403   shortfreq_t max_ifshift;      
01405   ann_t announces;              
01407   int preamp[MAXDBLSTSIZ];      
01408   int attenuator[MAXDBLSTSIZ];  
01410   setting_t has_get_func;       
01411   setting_t has_set_func;       
01412   setting_t has_get_level;      
01413   setting_t has_set_level;      
01414   setting_t has_get_parm;       
01415   setting_t has_set_parm;       
01417   gran_t level_gran[RIG_SETTING_MAX];   
01418   gran_t parm_gran[RIG_SETTING_MAX];    
01421         /* 
01422          * non overridable fields, internal use
01423          */
01424 
01425   int hold_decode;      
01426   vfo_t current_vfo;    
01427   int vfo_list;         
01428   int comm_state;       
01429   rig_ptr_t priv;       
01430   rig_ptr_t obj;        
01432   int transceive;       
01433   int poll_interval;    
01434   freq_t current_freq;  
01435   rmode_t current_mode; 
01436   pbwidth_t current_width;      
01437   vfo_t tx_vfo;         
01438   int mode_list;                
01440 };
01441 
01442 
01443 typedef int (*vprintf_cb_t) (enum rig_debug_level_e, rig_ptr_t, const char *, va_list);
01444 
01445 typedef int (*freq_cb_t) (RIG *, vfo_t, freq_t, rig_ptr_t);
01446 typedef int (*mode_cb_t) (RIG *, vfo_t, rmode_t, pbwidth_t, rig_ptr_t);
01447 typedef int (*vfo_cb_t) (RIG *, vfo_t, rig_ptr_t);
01448 typedef int (*ptt_cb_t) (RIG *, vfo_t, ptt_t, rig_ptr_t);
01449 typedef int (*dcd_cb_t) (RIG *, vfo_t, dcd_t, rig_ptr_t);
01450 typedef int (*pltune_cb_t) (RIG *, vfo_t, freq_t *, rmode_t *, pbwidth_t *, rig_ptr_t);
01451 
01469 struct rig_callbacks {
01470   freq_cb_t freq_event; 
01471   rig_ptr_t freq_arg;   
01472   mode_cb_t mode_event; 
01473   rig_ptr_t mode_arg;   
01474   vfo_cb_t vfo_event;   
01475   rig_ptr_t vfo_arg;    
01476   ptt_cb_t ptt_event;   
01477   rig_ptr_t ptt_arg;    
01478   dcd_cb_t dcd_event;   
01479   rig_ptr_t dcd_arg;    
01480   pltune_cb_t pltune;   
01481   rig_ptr_t pltune_arg; 
01482   /* etc.. */
01483 };
01484 
01494 struct rig {
01495   struct rig_caps *caps;                
01496   struct rig_state state;               
01497   struct rig_callbacks callbacks;       
01498 };
01499 
01500 
01501 
01502 /* --------------- API function prototypes -----------------*/
01503 
01504 extern HAMLIB_EXPORT(RIG *) rig_init HAMLIB_PARAMS((rig_model_t rig_model));
01505 extern HAMLIB_EXPORT(int) rig_open HAMLIB_PARAMS((RIG *rig));
01506 
01507   /*
01508    *  General API commands, from most primitive to least.. :()
01509    *  List Set/Get functions pairs
01510    */
01511 
01512 extern HAMLIB_EXPORT(int) rig_set_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t freq));
01513 extern HAMLIB_EXPORT(int) rig_get_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *freq));
01514 
01515 extern HAMLIB_EXPORT(int) rig_set_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t mode, pbwidth_t width));
01516 extern HAMLIB_EXPORT(int) rig_get_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *mode, pbwidth_t *width));
01517 
01518 extern HAMLIB_EXPORT(int) rig_set_vfo HAMLIB_PARAMS((RIG *rig, vfo_t vfo));
01519 extern HAMLIB_EXPORT(int) rig_get_vfo HAMLIB_PARAMS((RIG *rig, vfo_t *vfo));
01520 
01521 extern HAMLIB_EXPORT(int) rig_set_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t ptt));
01522 extern HAMLIB_EXPORT(int) rig_get_ptt HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ptt_t *ptt));
01523 
01524 extern HAMLIB_EXPORT(int) rig_get_dcd HAMLIB_PARAMS((RIG *rig, vfo_t vfo, dcd_t *dcd));
01525 
01526 extern HAMLIB_EXPORT(int) rig_set_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t rptr_shift));
01527 extern HAMLIB_EXPORT(int) rig_get_rptr_shift HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rptr_shift_t *rptr_shift));
01528 extern HAMLIB_EXPORT(int) rig_set_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rptr_offs));
01529 extern HAMLIB_EXPORT(int) rig_get_rptr_offs HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rptr_offs));
01530 
01531 extern HAMLIB_EXPORT(int) rig_set_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01532 extern HAMLIB_EXPORT(int) rig_get_ctcss_tone HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01533 extern HAMLIB_EXPORT(int) rig_set_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01534 extern HAMLIB_EXPORT(int) rig_get_dcs_code HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01535 
01536 extern HAMLIB_EXPORT(int) rig_set_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t tone));
01537 extern HAMLIB_EXPORT(int) rig_get_ctcss_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *tone));
01538 extern HAMLIB_EXPORT(int) rig_set_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t code));
01539 extern HAMLIB_EXPORT(int) rig_get_dcs_sql HAMLIB_PARAMS((RIG *rig, vfo_t vfo, tone_t *code));
01540 
01541 extern HAMLIB_EXPORT(int) rig_set_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t tx_freq));
01542 extern HAMLIB_EXPORT(int) rig_get_split_freq HAMLIB_PARAMS((RIG *rig, vfo_t vfo, freq_t *tx_freq));
01543 extern HAMLIB_EXPORT(int) rig_set_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t tx_mode, pbwidth_t tx_width));
01544 extern HAMLIB_EXPORT(int) rig_get_split_mode HAMLIB_PARAMS((RIG *rig, vfo_t vfo, rmode_t *tx_mode, pbwidth_t *tx_width));
01545 extern HAMLIB_EXPORT(int) rig_set_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t split, vfo_t tx_vfo));
01546 extern HAMLIB_EXPORT(int) rig_get_split_vfo HAMLIB_PARAMS((RIG*, vfo_t rx_vfo, split_t *split, vfo_t *tx_vfo));
01547 #define rig_set_split(r,v,s) rig_set_split_vfo((r),(v),(s),RIG_VFO_CURR)
01548 #define rig_get_split(r,v,s) ({ vfo_t _tx_vfo; rig_get_split_vfo((r),(v),(s),&_tx_vfo); })
01549 
01550 extern HAMLIB_EXPORT(int) rig_set_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t rit));
01551 extern HAMLIB_EXPORT(int) rig_get_rit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *rit));
01552 extern HAMLIB_EXPORT(int) rig_set_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t xit));
01553 extern HAMLIB_EXPORT(int) rig_get_xit HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *xit));
01554 
01555 extern HAMLIB_EXPORT(int) rig_set_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t ts));
01556 extern HAMLIB_EXPORT(int) rig_get_ts HAMLIB_PARAMS((RIG *rig, vfo_t vfo, shortfreq_t *ts));
01557 
01558 extern HAMLIB_EXPORT(int) rig_power2mW HAMLIB_PARAMS((RIG *rig, unsigned int *mwpower, float power, freq_t freq, rmode_t mode));
01559 extern HAMLIB_EXPORT(int) rig_mW2power HAMLIB_PARAMS((RIG *rig, float *power, unsigned int mwpower, freq_t freq, rmode_t mode));
01560 
01561 extern HAMLIB_EXPORT(shortfreq_t) rig_get_resolution HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01562 
01563 extern HAMLIB_EXPORT(int) rig_set_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t val));
01564 extern HAMLIB_EXPORT(int) rig_get_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t level, value_t *val));
01565 
01566 #define rig_get_strength(r,v,s) rig_get_level((r),(v),RIG_LEVEL_STRENGTH, (value_t*)(s))
01567 
01568 extern HAMLIB_EXPORT(int) rig_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t val));
01569 extern HAMLIB_EXPORT(int) rig_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm, value_t *val));
01570 
01571 extern HAMLIB_EXPORT(int) rig_set_conf HAMLIB_PARAMS((RIG *rig, token_t token, const char *val));
01572 extern HAMLIB_EXPORT(int) rig_get_conf HAMLIB_PARAMS((RIG *rig, token_t token, char *val));
01573 
01574 extern HAMLIB_EXPORT(int) rig_set_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t status));
01575 extern HAMLIB_EXPORT(int) rig_get_powerstat HAMLIB_PARAMS((RIG *rig, powerstat_t *status));
01576 
01577 extern HAMLIB_EXPORT(int) rig_reset HAMLIB_PARAMS((RIG *rig, reset_t reset));   /* dangerous! */
01578 
01579 extern HAMLIB_EXPORT(int) rig_set_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01580                         token_t token, value_t val));
01581 extern HAMLIB_EXPORT(int) rig_get_ext_level HAMLIB_PARAMS((RIG *rig, vfo_t vfo,
01582                         token_t token, value_t *val));
01583 
01584 extern HAMLIB_EXPORT(int) rig_set_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t val));
01585 extern HAMLIB_EXPORT(int) rig_get_ext_parm HAMLIB_PARAMS((RIG *rig, token_t token, value_t *val));
01586 
01587 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));
01588 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));
01589 extern HAMLIB_EXPORT(const struct confparams*) rig_ext_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01590 extern HAMLIB_EXPORT(const struct confparams *)  rig_ext_lookup_tok HAMLIB_PARAMS((RIG *rig, token_t token));
01591 extern HAMLIB_EXPORT(token_t) rig_ext_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01592 
01593 
01594 extern HAMLIB_EXPORT(int) rig_token_foreach HAMLIB_PARAMS((RIG *rig, int (*cfunc)(const struct confparams *, rig_ptr_t), rig_ptr_t data));
01595 extern HAMLIB_EXPORT(const struct confparams*) rig_confparam_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01596 extern HAMLIB_EXPORT(token_t) rig_token_lookup HAMLIB_PARAMS((RIG *rig, const char *name));
01597 
01598 extern HAMLIB_EXPORT(int) rig_close HAMLIB_PARAMS((RIG *rig));
01599 extern HAMLIB_EXPORT(int) rig_cleanup HAMLIB_PARAMS((RIG *rig));
01600 
01601 extern HAMLIB_EXPORT(int) rig_set_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t ant));  /* antenna */
01602 extern HAMLIB_EXPORT(int) rig_get_ant HAMLIB_PARAMS((RIG *rig, vfo_t vfo, ant_t *ant));
01603 
01604 extern HAMLIB_EXPORT(setting_t) rig_has_get_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01605 extern HAMLIB_EXPORT(setting_t) rig_has_set_level HAMLIB_PARAMS((RIG *rig, setting_t level));
01606 
01607 extern HAMLIB_EXPORT(setting_t) rig_has_get_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01608 extern HAMLIB_EXPORT(setting_t) rig_has_set_parm HAMLIB_PARAMS((RIG *rig, setting_t parm));
01609 
01610 extern HAMLIB_EXPORT(setting_t) rig_has_get_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01611 extern HAMLIB_EXPORT(setting_t) rig_has_set_func HAMLIB_PARAMS((RIG *rig, setting_t func));
01612 
01613 extern HAMLIB_EXPORT(int) rig_set_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int status));
01614 extern HAMLIB_EXPORT(int) rig_get_func HAMLIB_PARAMS((RIG *rig, vfo_t vfo, setting_t func, int *status));
01615 
01616 extern HAMLIB_EXPORT(int) rig_send_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *digits));
01617 extern HAMLIB_EXPORT(int) rig_recv_dtmf HAMLIB_PARAMS((RIG *rig, vfo_t vfo, char *digits, int *length));
01618 extern HAMLIB_EXPORT(int) rig_send_morse HAMLIB_PARAMS((RIG *rig, vfo_t vfo, const char *msg));
01619 
01620 extern HAMLIB_EXPORT(int) rig_set_bank HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int bank));
01621 extern HAMLIB_EXPORT(int) rig_set_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int ch));
01622 extern HAMLIB_EXPORT(int) rig_get_mem HAMLIB_PARAMS((RIG *rig, vfo_t vfo, int *ch));
01623 extern HAMLIB_EXPORT(int) rig_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_t vfo, vfo_op_t op));
01624 extern HAMLIB_EXPORT(vfo_op_t) rig_has_vfo_op HAMLIB_PARAMS((RIG *rig, vfo_op_t op));
01625 extern HAMLIB_EXPORT(int) rig_scan HAMLIB_PARAMS((RIG *rig, vfo_t vfo, scan_t scan, int ch));
01626 extern HAMLIB_EXPORT(scan_t) rig_has_scan HAMLIB_PARAMS((RIG *rig, scan_t scan));
01627 
01628 extern HAMLIB_EXPORT(int) rig_set_channel HAMLIB_PARAMS((RIG *rig, const channel_t *chan));     /* mem */
01629 extern HAMLIB_EXPORT(int) rig_get_channel HAMLIB_PARAMS((RIG *rig, channel_t *chan));
01630 
01631 extern HAMLIB_EXPORT(int) rig_set_chan_all HAMLIB_PARAMS((RIG *rig, const channel_t chans[]));
01632 extern HAMLIB_EXPORT(int) rig_get_chan_all HAMLIB_PARAMS((RIG *rig, channel_t chans[]));
01633 extern HAMLIB_EXPORT(int) rig_set_chan_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, rig_ptr_t));
01634 extern HAMLIB_EXPORT(int) rig_get_chan_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, rig_ptr_t));
01635 
01636 extern HAMLIB_EXPORT(int) rig_set_mem_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t));
01637 extern HAMLIB_EXPORT(int) rig_get_mem_all_cb HAMLIB_PARAMS((RIG *rig, chan_cb_t chan_cb, confval_cb_t parm_cb, rig_ptr_t));
01638 extern HAMLIB_EXPORT(int) rig_set_mem_all HAMLIB_PARAMS((RIG *rig, const channel_t *chan, const struct confparams *, const value_t *));
01639 extern HAMLIB_EXPORT(int) rig_get_mem_all HAMLIB_PARAMS((RIG *rig, channel_t *chan, const struct confparams *, value_t *));
01640 extern HAMLIB_EXPORT(const chan_t *) rig_lookup_mem_caps HAMLIB_PARAMS((RIG *rig, int ch));
01641 extern HAMLIB_EXPORT(int) rig_mem_count HAMLIB_PARAMS((RIG *rig));
01642 
01643 
01644 extern HAMLIB_EXPORT(int) rig_set_trn HAMLIB_PARAMS((RIG *rig, int trn));
01645 extern HAMLIB_EXPORT(int) rig_get_trn HAMLIB_PARAMS((RIG *rig, int *trn));
01646 extern HAMLIB_EXPORT(int) rig_set_freq_callback HAMLIB_PARAMS((RIG *, freq_cb_t, rig_ptr_t));
01647 extern HAMLIB_EXPORT(int) rig_set_mode_callback HAMLIB_PARAMS((RIG *, mode_cb_t, rig_ptr_t));
01648 extern HAMLIB_EXPORT(int) rig_set_vfo_callback HAMLIB_PARAMS((RIG *, vfo_cb_t, rig_ptr_t));
01649 extern HAMLIB_EXPORT(int) rig_set_ptt_callback HAMLIB_PARAMS((RIG *, ptt_cb_t, rig_ptr_t));
01650 extern HAMLIB_EXPORT(int) rig_set_dcd_callback HAMLIB_PARAMS((RIG *, dcd_cb_t, rig_ptr_t));
01651 extern HAMLIB_EXPORT(int) rig_set_pltune_callback HAMLIB_PARAMS((RIG *, pltune_cb_t, rig_ptr_t));
01652 
01653 extern HAMLIB_EXPORT(const char *) rig_get_info HAMLIB_PARAMS((RIG *rig));
01654 
01655 extern HAMLIB_EXPORT(const struct rig_caps *) rig_get_caps HAMLIB_PARAMS((rig_model_t rig_model));
01656 extern HAMLIB_EXPORT(const freq_range_t *) rig_get_range HAMLIB_PARAMS((const freq_range_t range_list[], freq_t freq, rmode_t mode));
01657 
01658 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_normal HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01659 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_narrow HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01660 extern HAMLIB_EXPORT(pbwidth_t) rig_passband_wide HAMLIB_PARAMS((RIG *rig, rmode_t mode));
01661 
01662 extern HAMLIB_EXPORT(const char *) rigerror HAMLIB_PARAMS((int errnum));
01663 
01664 extern HAMLIB_EXPORT(int) rig_setting2idx HAMLIB_PARAMS((setting_t s));
01665 #define rig_idx2setting(i) (1UL<<(i))
01666 
01667 /*
01668  * Even if these functions are prefixed with "rig_", they are not rig specific
01669  * Maybe "hamlib_" would have been better. Let me know. --SF
01670  */
01671 extern HAMLIB_EXPORT(void) rig_set_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01672 #define rig_set_debug_level(level) rig_set_debug(level)
01673 extern HAMLIB_EXPORT(int) rig_need_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level));
01674 extern HAMLIB_EXPORT(void) rig_debug HAMLIB_PARAMS((enum rig_debug_level_e debug_level, const char *fmt, ...));
01675 extern HAMLIB_EXPORT(vprintf_cb_t) rig_set_debug_callback HAMLIB_PARAMS((vprintf_cb_t cb, rig_ptr_t arg));
01676 extern HAMLIB_EXPORT(FILE*) rig_set_debug_file HAMLIB_PARAMS((FILE *stream));
01677 
01678 extern HAMLIB_EXPORT(int) rig_register HAMLIB_PARAMS((const struct rig_caps *caps));
01679 extern HAMLIB_EXPORT(int) rig_unregister HAMLIB_PARAMS((rig_model_t rig_model));
01680 extern HAMLIB_EXPORT(int) rig_list_foreach HAMLIB_PARAMS((int (*cfunc)(const struct rig_caps*, rig_ptr_t), rig_ptr_t data));
01681 extern HAMLIB_EXPORT(int) rig_load_backend HAMLIB_PARAMS((const char *be_name));
01682 extern HAMLIB_EXPORT(int) rig_check_backend HAMLIB_PARAMS((rig_model_t rig_model));
01683 extern HAMLIB_EXPORT(int) rig_load_all_backends HAMLIB_PARAMS((void));
01684 
01685 typedef int (*rig_probe_func_t)(const hamlib_port_t *, rig_model_t, rig_ptr_t);
01686 extern HAMLIB_EXPORT(int) rig_probe_all HAMLIB_PARAMS((hamlib_port_t *p, rig_probe_func_t, rig_ptr_t));
01687 extern HAMLIB_EXPORT(rig_model_t) rig_probe HAMLIB_PARAMS((hamlib_port_t *p));
01688 
01689 
01690 /* Misc calls */
01691 extern HAMLIB_EXPORT(const char *) rig_strrmode(rmode_t mode);
01692 extern HAMLIB_EXPORT(const char *) rig_strvfo(vfo_t vfo);
01693 extern HAMLIB_EXPORT(const char *) rig_strfunc(setting_t);
01694 extern HAMLIB_EXPORT(const char *) rig_strlevel(setting_t);
01695 extern HAMLIB_EXPORT(const char *) rig_strparm(setting_t);
01696 extern HAMLIB_EXPORT(const char *) rig_strptrshift(rptr_shift_t);
01697 extern HAMLIB_EXPORT(const char *) rig_strvfop(vfo_op_t op);
01698 extern HAMLIB_EXPORT(const char *) rig_strscan(scan_t scan);
01699 extern HAMLIB_EXPORT(const char *) rig_strstatus(enum rig_status_e status);
01700 extern HAMLIB_EXPORT(const char *) rig_strmtype(chan_type_t mtype);
01701 
01702 extern HAMLIB_EXPORT(rmode_t) rig_parse_mode(const char *s);
01703 extern HAMLIB_EXPORT(vfo_t) rig_parse_vfo(const char *s);
01704 extern HAMLIB_EXPORT(setting_t) rig_parse_func(const char *s);
01705 extern HAMLIB_EXPORT(setting_t) rig_parse_level(const char *s);
01706 extern HAMLIB_EXPORT(setting_t) rig_parse_parm(const char *s);
01707 extern HAMLIB_EXPORT(vfo_op_t) rig_parse_vfo_op(const char *s);
01708 extern HAMLIB_EXPORT(scan_t) rig_parse_scan(const char *s);
01709 extern HAMLIB_EXPORT(rptr_shift_t) rig_parse_rptr_shift(const char *s);
01710 extern HAMLIB_EXPORT(chan_type_t) rig_parse_mtype(const char *s);
01711 
01712 
01713 __END_DECLS
01714 
01715 #endif /* _RIG_H */
01716 
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Defines

Generated by doxygen 1.7.5

Hamlib documentation for version 1.2.14 -- Fri Dec 23 2011 23:24:31
Project page: http://www.hamlib.org